home *** CD-ROM | disk | FTP | other *** search
/ ADA Programming Guide / ADA Programming Guide.iso / ada_lrm / lr9vt.src < prev    next >
Text File  |  1996-01-30  |  126KB  |  2,908 lines
  1.  
  2. --    Package specification SMG is a "data-only" code interface of the 
  3. --        SMG$ routines from VMS V4.7 VAX Ada V1.4
  4. --        
  5. --    Initial received and tested on 6/10/88
  6. --    Originally written by Bryan Jervey, Norfolk State University
  7. --    ReDTEA Project (United State Army)
  8. --------------------------------------------------------------------------
  9. --
  10. --    Revisions history and notes:
  11. --
  12. --    8/28/88 
  13. --     1)     Minor Corrections.
  14. --    2)    Corrections in data types, parameter modes.
  15. --    3)    Added all parameter objects to routines missing in previous
  16. --        version.
  17. --    4)    Included separate routines (except for functions CURSOR_COLUMN 
  18. --        and CURSOR_ROW) to include STATUS : out COND_VALUE as first
  19. --        parameter.
  20. --    5)    Deleted the following routines in conformance with VMS V5.0
  21. --        changes:  ALLOW_ESCAPE, PUT_WITH_SCROLL, 
  22. --        PUT_VIRTUAL_DISPLAY_ENCODED.  (Have not added new SMG routines
  23. --        unique to VMS V5.0);
  24. --    6)    Since Ada does not support default values for parameter
  25. --        items with mode "out", created additional routines with
  26. --        named extensions " _1 " that mirror the standard routines
  27. --        but without optional "out" mode parameter objects.
  28. --    
  29. --------------------------------------------------------------------------
  30. --    For specific explaination of parameter objects in the following
  31. --    routines type
  32. --            $ HELP RTL SMG$ SMG$routine_name
  33. --
  34. -------------------------------------------------------------------------
  35.  
  36. with STARLET; 
  37. with SYSTEM;                
  38. with CONDITION_HANDLING; 
  39.  
  40. package SMG is 
  41.  
  42.   subtype ADDRESS is SYSTEM.ADDRESS; 
  43.   subtype AST_PROCEDURE is SYSTEM.AST_HANDLER; 
  44.   subtype BOOLEAN is STANDARD.BOOLEAN; 
  45.   subtype BYTE_SIGNED is STANDARD.SHORT_SHORT_INTEGER; 
  46.   subtype BYTE_UNSIGNED is SYSTEM.UNSIGNED_BYTE; 
  47.   subtype CHAR_STRING is STRING; 
  48.   subtype CONTEXT_TYPE is STARLET.CONTEXT_TYPE; 
  49.   subtype COND_VALUE is CONDITION_HANDLING.COND_VALUE_TYPE; 
  50.   subtype LONGWORD_SIGNED is INTEGER; 
  51.   subtype LONGWORD_UNSIGNED is SYSTEM.UNSIGNED_LONGWORD; 
  52.   subtype MASK_LONGWORD is SYSTEM.UNSIGNED_LONGWORD; 
  53.   subtype NULL_ARG is SYSTEM.UNSIGNED_LONGWORD; 
  54.   subtype USER_ARG is STARLET.USER_ARG_TYPE; 
  55.   subtype VECTOR_BYTE_UNSIGNED is SYSTEM.UNSIGNED_BYTE; 
  56.   subtype WORD_SIGNED is SHORT_INTEGER; 
  57.   subtype WORD_UNSIGNED is SYSTEM.UNSIGNED_WORD; 
  58.  
  59.   --------------------------------------------------------------------------
  60.   --------------------------------------------------------------------------
  61.   --    adds a keypad key definition to a table of key definitions.
  62.   --   
  63.  
  64.   procedure ADD_KEY_DEF --                                                  
  65.   (KEY_TABLE_ID : in LONGWORD_UNSIGNED; 
  66.    KEY_NAME     : in CHAR_STRING; 
  67.    IF_STATE     : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  68.    ATTRIBUTES   : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER; 
  69.    EQUIV_STRING : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  70.    STATE_STRING : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER); 
  71.  
  72.   procedure ADD_KEY_DEF --                                                  
  73.   (STATUS       : out COND_VALUE; 
  74.    KEY_TABLE_ID : in LONGWORD_UNSIGNED; 
  75.    KEY_NAME     : in CHAR_STRING; 
  76.    IF_STATE     : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  77.    ATTRIBUTES   : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER; 
  78.    EQUIV_STRING : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  79.    STATE_STRING : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER); 
  80.  
  81.   pragma INTERFACE(RTL, ADD_KEY_DEF); 
  82.  
  83.   pragma IMPORT_PROCEDURE(ADD_KEY_DEF, "SMG$ADD_KEY_DEF", (LONGWORD_UNSIGNED, 
  84.     CHAR_STRING, CHAR_STRING, MASK_LONGWORD, CHAR_STRING, CHAR_STRING)); 
  85.  
  86.   pragma IMPORT_PROCEDURE(ADD_KEY_DEF, "SMG$ADD_KEY_DEF", (COND_VALUE, 
  87.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, MASK_LONGWORD, CHAR_STRING, 
  88.     CHAR_STRING)); 
  89.  
  90.  
  91.   --------------------------------------------------------------------------
  92.   -------------------------------------------------------------------------- 
  93.   --    saves, or batches, all output to a virtual display until a matching
  94.   --    call to END_DISPLAY_UPDATE is encountered.
  95.   --
  96.  
  97.   procedure BEGIN_DISPLAY_UPDATE --
  98.   (DISPLAY_ID : in LONGWORD_UNSIGNED); 
  99.  
  100.   procedure BEGIN_DISPLAY_UPDATE --
  101.   (STATUS     : out COND_VALUE; 
  102.    DISPLAY_ID : in LONGWORD_UNSIGNED); 
  103.  
  104.   pragma INTERFACE(RTL, BEGIN_DISPLAY_UPDATE); 
  105.  
  106.   pragma IMPORT_PROCEDURE(BEGIN_DISPLAY_UPDATE, "SMG$BEGIN_DISPLAY_UPDATE", (
  107.     LONGWORD_UNSIGNED)); 
  108.  
  109.   pragma IMPORT_PROCEDURE(BEGIN_DISPLAY_UPDATE, "SMG$BEGIN_DISPLAY_UPDATE", (
  110.     COND_VALUE, LONGWORD_UNSIGNED)); 
  111.  
  112.   --------------------------------------------------------------------------
  113.   --------------------------------------------------------------------------
  114.   --    saves, or batches, all output to a pasteboard until a matching call
  115.   --    to END_PASTEBOARD_DATE is encountered.
  116.   --
  117.  
  118.   procedure BEGIN_PASTEBOARD_UPDATE --
  119.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  120.  
  121.   procedure BEGIN_PASTEBOARD_UPDATE --
  122.   (STATUS        : out COND_VALUE; 
  123.    PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  124.  
  125.   pragma INTERFACE(RTL, BEGIN_PASTEBOARD_UPDATE); 
  126.  
  127.   pragma IMPORT_PROCEDURE(BEGIN_PASTEBOARD_UPDATE, "SMG$BEGIN_PASTEBOARD_UPDATE"
  128.     , (LONGWORD_UNSIGNED)); 
  129.  
  130.   pragma IMPORT_PROCEDURE(BEGIN_PASTEBOARD_UPDATE, "SMG$BEGIN_PASTEBOARD_UPDATE"
  131.     , (COND_VALUE, LONGWORD_UNSIGNED)); 
  132.  
  133.   --------------------------------------------------------------------------
  134.   --------------------------------------------------------------------------
  135.   --    immediately cancels any read-in-progress that was issued by
  136.   --    READ_COMPOSED_LINE, READ_KEYSTROKE, READ_STRING or READ_VERIFY
  137.   --
  138.  
  139.   procedure CANCEL_INPUT --
  140.   (KEYBOARD_ID : in LONGWORD_UNSIGNED); 
  141.  
  142.   procedure CANCEL_INPUT --
  143.   (STATUS      : out COND_VALUE; 
  144.    KEYBOARD_ID : in LONGWORD_UNSIGNED); 
  145.  
  146.   pragma INTERFACE(RTL, CANCEL_INPUT); 
  147.  
  148.   pragma IMPORT_PROCEDURE(CANCEL_INPUT, "SMG$CANCEL_INPUT", (LONGWORD_UNSIGNED))
  149.     ; 
  150.  
  151.   pragma IMPORT_PROCEDURE(CANCEL_INPUT, "SMG$CANCEL_INPUT", (COND_VALUE, 
  152.     LONGWORD_UNSIGNED)); 
  153.  
  154.   --------------------------------------------------------------------------
  155.   ---------------------------------------------------------------------------
  156.   --    changes the width, height and background color associated with a
  157.   --    pasteboard.
  158.   --
  159.  
  160.   procedure CHANGE_PBD_CHARACTERISTICS --
  161.   (PASTEBOARD_ID              : in LONGWORD_UNSIGNED; 
  162.    DESIRED_WIDTH              : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  163.      NULL_PARAMETER; 
  164.    RESULTING_WIDTH            : out LONGWORD_SIGNED; 
  165.    DESIRED_HEIGHT             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  166.      NULL_PARAMETER; 
  167.    RESULTING_HEIGHT           : out LONGWORD_SIGNED; 
  168.    DESIRED_BACKGROUND_COLOR   : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'
  169.      NULL_PARAMETER; 
  170.    RESULTING_BACKGROUND_COLOR : out LONGWORD_UNSIGNED); 
  171.  
  172.   procedure CHANGE_PBD_CHARACTERISTICS --
  173.   (STATUS                     : out COND_VALUE; 
  174.    PASTEBOARD_ID              : in LONGWORD_UNSIGNED; 
  175.    DESIRED_WIDTH              : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  176.      NULL_PARAMETER; 
  177.    RESULTING_WIDTH            : out LONGWORD_SIGNED; 
  178.    DESIRED_HEIGHT             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  179.      NULL_PARAMETER; 
  180.    RESULTING_HEIGHT           : out LONGWORD_SIGNED; 
  181.    DESIRED_BACKGROUND_COLOR   : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'
  182.      NULL_PARAMETER; 
  183.    RESULTING_BACKGROUND_COLOR : out LONGWORD_UNSIGNED); 
  184.  
  185.   procedure CHANGE_PBD_CHARACTERISTICS_1 --
  186.   (PASTEBOARD_ID            : in LONGWORD_UNSIGNED; 
  187.    DESIRED_WIDTH            : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  188.      NULL_PARAMETER; 
  189.    DESIRED_HEIGHT           : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  190.      NULL_PARAMETER; 
  191.    DESIRED_BACKGROUND_COLOR : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'
  192.      NULL_PARAMETER); 
  193.  
  194.   procedure CHANGE_PBD_CHARACTERISTICS_1 --
  195.   (STATUS                   : out COND_VALUE; 
  196.    PASTEBOARD_ID            : in LONGWORD_UNSIGNED; 
  197.    DESIRED_WIDTH            : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  198.      NULL_PARAMETER; 
  199.    DESIRED_HEIGHT           : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  200.      NULL_PARAMETER; 
  201.    DESIRED_BACKGROUND_COLOR : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'
  202.      NULL_PARAMETER); 
  203.  
  204.   pragma INTERFACE(RTL, CHANGE_PBD_CHARACTERISTICS); 
  205.  
  206.   pragma INTERFACE(RTL, CHANGE_PBD_CHARACTERISTICS_1); 
  207.  
  208.   pragma IMPORT_PROCEDURE(CHANGE_PBD_CHARACTERISTICS, 
  209.     "SMG$CHANGE_PBD_CHARACTERISTICS", (LONGWORD_UNSIGNED, LONGWORD_SIGNED, 
  210.     LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_UNSIGNED, 
  211.     LONGWORD_UNSIGNED)); 
  212.  
  213.   pragma IMPORT_PROCEDURE(CHANGE_PBD_CHARACTERISTICS, 
  214.     "SMG$CHANGE_PBD_CHARACTERISTICS", (COND_VALUE, LONGWORD_UNSIGNED, 
  215.     LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  216.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  217.  
  218.   pragma IMPORT_PROCEDURE(CHANGE_PBD_CHARACTERISTICS_1, 
  219.     "SMG$CHANGE_PBD_CHARACTERISTICS", (LONGWORD_UNSIGNED, LONGWORD_SIGNED, 
  220.     LONGWORD_SIGNED, LONGWORD_UNSIGNED)); 
  221.  
  222.   pragma IMPORT_PROCEDURE(CHANGE_PBD_CHARACTERISTICS_1, 
  223.     "SMG$CHANGE_PBD_CHARACTERISTICS", (COND_VALUE, LONGWORD_UNSIGNED, 
  224.     LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_UNSIGNED)); 
  225.  
  226.   --------------------------------------------------------------------------
  227.   --------------------------------------------------------------------------
  228.   --    changes the video attributes for all or part of a virtual display.
  229.   --
  230.  
  231.   procedure CHANGE_RENDITION --
  232.   (DISPLAY_ID                          : in LONGWORD_UNSIGNED; 
  233.    START_ROW, START_COL, ROWS, COLUMNS : in LONGWORD_SIGNED; 
  234.    RENDITION_SET                       : in LONGWORD_UNSIGNED := 
  235.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  236.    RENDITION_COMPLEMENT                : in MASK_LONGWORD := MASK_LONGWORD'
  237.      NULL_PARAMETER); 
  238.  
  239.   procedure CHANGE_RENDITION --
  240.   (STATUS                              : out COND_VALUE; 
  241.    DISPLAY_ID                          : in LONGWORD_UNSIGNED; 
  242.    START_ROW, START_COL, ROWS, COLUMNS : in LONGWORD_SIGNED; 
  243.    RENDITION_SET                       : in LONGWORD_UNSIGNED := 
  244.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  245.    RENDITION_COMPLEMENT                : in MASK_LONGWORD := MASK_LONGWORD'
  246.      NULL_PARAMETER); 
  247.  
  248.   pragma INTERFACE(RTL, CHANGE_RENDITION); 
  249.  
  250.   pragma IMPORT_PROCEDURE(CHANGE_RENDITION, "SMG$CHANGE_RENDITION", (
  251.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  252.     LONGWORD_SIGNED, LONGWORD_UNSIGNED, MASK_LONGWORD)); 
  253.  
  254.   pragma IMPORT_PROCEDURE(CHANGE_RENDITION, "SMG$CHANGE_RENDITION", (COND_VALUE
  255.     , LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  256.     LONGWORD_SIGNED, LONGWORD_UNSIGNED, MASK_LONGWORD)); 
  257.  
  258.   --------------------------------------------------------------------------
  259.   --------------------------------------------------------------------------
  260.   --    lets you change the dimensions, border, and video attributes of a 
  261.   --    virtual display.
  262.   --
  263.  
  264.   procedure CHANGE_VIRTUAL_DISPLAY --
  265.   (DISPLAY_ID                           : in LONGWORD_UNSIGNED; 
  266.    ROWS, COLUMNS                        : in LONGWORD_SIGNED; 
  267.    DISPLAY_ATTRIBUTES, VIDEO_ATTRIBUTES : in MASK_LONGWORD := MASK_LONGWORD'
  268.      NULL_PARAMETER; 
  269.    CHAR_SET                             : in LONGWORD_UNSIGNED := 
  270.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  271.  
  272.   procedure CHANGE_VIRTUAL_DISPLAY --
  273.   (STATUS                               : out COND_VALUE; 
  274.    DISPLAY_ID                           : in LONGWORD_UNSIGNED; 
  275.    ROWS, COLUMNS                        : in LONGWORD_SIGNED; 
  276.    DISPLAY_ATTRIBUTES, VIDEO_ATTRIBUTES : in MASK_LONGWORD := MASK_LONGWORD'
  277.      NULL_PARAMETER; 
  278.    CHAR_SET                             : in LONGWORD_UNSIGNED := 
  279.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  280.  
  281.   pragma INTERFACE(RTL, CHANGE_VIRTUAL_DISPLAY); 
  282.  
  283.   pragma IMPORT_PROCEDURE(CHANGE_VIRTUAL_DISPLAY, "SMG$CHANGE_VIRTUAL_DISPLAY", 
  284.     (LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, MASK_LONGWORD, 
  285.     MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  286.  
  287.   pragma IMPORT_PROCEDURE(CHANGE_VIRTUAL_DISPLAY, "SMG$CHANGE_VIRTUAL_DISPLAY", 
  288.     (COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  289.     MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  290.  
  291.   --------------------------------------------------------------------------
  292.   --------------------------------------------------------------------------
  293.   --    checks to see whether a virtual display is covered by another 
  294.   --    virtual display.
  295.   --
  296.  
  297.   procedure CHECK_FOR_OCCLUSION --
  298.   (DISPLAY_ID, PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  299.    OCCLUSION_STATE           : out LONGWORD_SIGNED); 
  300.  
  301.   procedure CHECK_FOR_OCCLUSION --
  302.   (STATUS                    : out COND_VALUE; 
  303.    DISPLAY_ID, PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  304.    OCCLUSION_STATE           : out LONGWORD_SIGNED); 
  305.  
  306.   pragma INTERFACE(RTL, CHECK_FOR_OCCLUSION); 
  307.  
  308.   pragma IMPORT_PROCEDURE(CHECK_FOR_OCCLUSION, "SMG$CHECK_FOR_OCCLUSION", (
  309.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED)); 
  310.  
  311.   pragma IMPORT_PROCEDURE(CHECK_FOR_OCCLUSION, "SMG$CHECK_FOR_OCCLUSION", (
  312.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED)); 
  313.  
  314.   --------------------------------------------------------------------------
  315.   --------------------------------------------------------------------------
  316.   --    controls buffering, minimal updating, whether the screen is cleared
  317.   --    when the pasteboard is deleted, and whether tab characters are
  318.   --    used for screen formatting.
  319.   --
  320.  
  321.   procedure CONTROL_MODE --
  322.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  323.    NEW_MODE      : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'NULL_PARAMETER; 
  324.    OLD_MODE      : out LONGWORD_UNSIGNED); 
  325.  
  326.   procedure CONTROL_MODE --
  327.   (STATUS        : out COND_VALUE; 
  328.    PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  329.    NEW_MODE      : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'NULL_PARAMETER; 
  330.    OLD_MODE      : out LONGWORD_UNSIGNED); 
  331.  
  332.   procedure CONTROL_MODE_1 --
  333.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  334.    NEW_MODE      : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'NULL_PARAMETER); 
  335.  
  336.   procedure CONTROL_MODE_1 --
  337.   (STATUS        : out COND_VALUE; 
  338.    PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  339.    NEW_MODE      : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'NULL_PARAMETER); 
  340.  
  341.  
  342.   pragma INTERFACE(RTL, CONTROL_MODE); 
  343.  
  344.   pragma INTERFACE(RTL, CONTROL_MODE_1); 
  345.  
  346.   pragma IMPORT_PROCEDURE(CONTROL_MODE, "SMG$CONTROL_MODE", (LONGWORD_UNSIGNED, 
  347.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  348.  
  349.   pragma IMPORT_PROCEDURE(CONTROL_MODE, "SMG$CONTROL_MODE", (COND_VALUE, 
  350.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  351.  
  352.   pragma IMPORT_PROCEDURE(CONTROL_MODE_1, "SMG$CONTROL_MODE", (LONGWORD_UNSIGNED
  353.     , LONGWORD_UNSIGNED)); 
  354.  
  355.   pragma IMPORT_PROCEDURE(CONTROL_MODE_1, "SMG$CONTROL_MODE", (COND_VALUE, 
  356.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  357.  
  358.   --------------------------------------------------------------------------
  359.   --------------------------------------------------------------------------
  360.   --    creates a copy of an existing virtual display and assigns to it
  361.   --    a new virtual display number.
  362.   --
  363.  
  364.   procedure COPY_VIRTUAL_DISPLAY --
  365.   (CURR_DISPLAY_ID : in LONGWORD_UNSIGNED; 
  366.    NEW_DISPLAY_ID  : out LONGWORD_UNSIGNED); 
  367.  
  368.   procedure COPY_VIRTUAL_DISPLAY --
  369.   (STATUS          : out COND_VALUE; 
  370.    CURR_DISPLAY_ID : in LONGWORD_UNSIGNED; 
  371.    NEW_DISPLAY_ID  : out LONGWORD_UNSIGNED); 
  372.  
  373.   pragma INTERFACE(RTL, COPY_VIRTUAL_DISPLAY); 
  374.  
  375.   pragma IMPORT_PROCEDURE(COPY_VIRTUAL_DISPLAY, "SMG$COPY_VIRTUAL_DISPLAY", (
  376.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  377.  
  378.   pragma IMPORT_PROCEDURE(COPY_VIRTUAL_DISPLAY, "SMG$COPY_VIRTUAL_DISPLAY", (
  379.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  380.  
  381.   --------------------------------------------------------------------------
  382.   --------------------------------------------------------------------------
  383.   --    creates a table for key definitions.
  384.   --
  385.  
  386.   procedure CREATE_KEY_TABLE --
  387.   (NEW_KEY_TABLE_ID : out LONGWORD_UNSIGNED); 
  388.  
  389.   procedure CREATE_KEY_TABLE --
  390.   (STATUS           : out COND_VALUE; 
  391.    NEW_KEY_TABLE_ID : out LONGWORD_UNSIGNED); 
  392.  
  393.   pragma INTERFACE(RTL, CREATE_KEY_TABLE); 
  394.  
  395.   pragma IMPORT_PROCEDURE(CREATE_KEY_TABLE, "SMG$CREATE_KEY_TABLE", (
  396.     LONGWORD_UNSIGNED)); 
  397.  
  398.   pragma IMPORT_PROCEDURE(CREATE_KEY_TABLE, "SMG$CREATE_KEY_TABLE", (COND_VALUE
  399.     , LONGWORD_UNSIGNED)); 
  400.  
  401.   --------------------------------------------------------------------------
  402.   --------------------------------------------------------------------------
  403.   --    creates a pasteboard and returns its assigned pasteboard-id.
  404.   -- 
  405.  
  406.   procedure CREATE_PASTEBOARD --
  407.   (NEW_PASTEBOARD_ID    : out LONGWORD_UNSIGNED; 
  408.    OUTPUT_DEVICE        : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  409.    PB_ROWS, PB_COLUMNS  : out LONGWORD_SIGNED; 
  410.    PRESERVE_SCREEN_FLAG : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER); 
  411.  
  412.   procedure CREATE_PASTEBOARD --
  413.   (STATUS               : out COND_VALUE; 
  414.    NEW_PASTEBOARD_ID    : out LONGWORD_UNSIGNED; 
  415.    OUTPUT_DEVICE        : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  416.    PB_ROWS, PB_COLUMNS  : out LONGWORD_SIGNED; 
  417.    PRESERVE_SCREEN_FLAG : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER); 
  418.  
  419.   procedure CREATE_PASTEBOARD_1 --
  420.   (NEW_PASTEBOARD_ID    : out LONGWORD_UNSIGNED; 
  421.    OUTPUT_DEVICE        : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  422.    PRESERVE_SCREEN_FLAG : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER); 
  423.  
  424.   procedure CREATE_PASTEBOARD_1 --
  425.   (STATUS               : out COND_VALUE; 
  426.    NEW_PASTEBOARD_ID    : out LONGWORD_UNSIGNED; 
  427.    OUTPUT_DEVICE        : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  428.    PRESERVE_SCREEN_FLAG : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER); 
  429.  
  430.   pragma INTERFACE(RTL, CREATE_PASTEBOARD); 
  431.  
  432.   pragma INTERFACE(RTL, CREATE_PASTEBOARD_1); 
  433.  
  434.   pragma IMPORT_PROCEDURE(CREATE_PASTEBOARD, "SMG$CREATE_PASTEBOARD", (
  435.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  436.     MASK_LONGWORD)); 
  437.  
  438.   pragma IMPORT_PROCEDURE(CREATE_PASTEBOARD, "SMG$CREATE_PASTEBOARD", (
  439.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, LONGWORD_SIGNED
  440.     , MASK_LONGWORD)); 
  441.  
  442.   pragma IMPORT_PROCEDURE(CREATE_PASTEBOARD_1, "SMG$CREATE_PASTEBOARD", (
  443.     LONGWORD_UNSIGNED, CHAR_STRING, MASK_LONGWORD)); 
  444.  
  445.   pragma IMPORT_PROCEDURE(CREATE_PASTEBOARD_1, "SMG$CREATE_PASTEBOARD", (
  446.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, MASK_LONGWORD)); 
  447.  
  448.   --------------------------------------------------------------------------
  449.   --------------------------------------------------------------------------
  450.   --    creates a virtual display and returns its assigned display id.
  451.   --  
  452.  
  453.   procedure CREATE_VIRTUAL_DISPLAY --
  454.   (NUM_ROWS, NUM_COLUMNS : in LONGWORD_SIGNED; 
  455.    NEW_DISPLAY_ID        : out LONGWORD_UNSIGNED; 
  456.    DISPLAY_ATTRIBUTES    : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'
  457.      NULL_PARAMETER; 
  458.    VIDEO_ATTRIBUTES      : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER; 
  459.    CHAR_SET              : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'
  460.      NULL_PARAMETER); 
  461.  
  462.   procedure CREATE_VIRTUAL_DISPLAY --
  463.   (STATUS                : out COND_VALUE; 
  464.    NUM_ROWS, NUM_COLUMNS : in LONGWORD_SIGNED; 
  465.    NEW_DISPLAY_ID        : out LONGWORD_UNSIGNED; 
  466.    DISPLAY_ATTRIBUTES    : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'
  467.      NULL_PARAMETER; 
  468.    VIDEO_ATTRIBUTES      : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER; 
  469.    CHAR_SET              : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'
  470.      NULL_PARAMETER); 
  471.  
  472.   pragma INTERFACE(RTL, CREATE_VIRTUAL_DISPLAY); 
  473.  
  474.   pragma IMPORT_PROCEDURE(CREATE_VIRTUAL_DISPLAY, "SMG$CREATE_VIRTUAL_DISPLAY", 
  475.     (LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, 
  476.     MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  477.  
  478.   pragma IMPORT_PROCEDURE(CREATE_VIRTUAL_DISPLAY, "SMG$CREATE_VIRTUAL_DISPLAY", 
  479.     (COND_VALUE, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_UNSIGNED, 
  480.     LONGWORD_UNSIGNED, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  481.  
  482.   --------------------------------------------------------------------------
  483.   --------------------------------------------------------------------------
  484.   --    creates a virtual keyboard and returns its assigned keyboard-id.
  485.   --
  486.  
  487.   procedure CREATE_VIRTUAL_KEYBOARD --
  488.   (NEW_KEYBOARD_ID            : out LONGWORD_UNSIGNED; 
  489.    FILESPEC, DEFAULT_FILESPEC : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  490.    RESULTANT_FILESPEC         : out CHAR_STRING; 
  491.    RECALL_SIZE                : in BYTE_UNSIGNED := BYTE_UNSIGNED'NULL_PARAMETER
  492.      ); 
  493.  
  494.   procedure CREATE_VIRTUAL_KEYBOARD --
  495.   (STATUS                     : out COND_VALUE; 
  496.    NEW_KEYBOARD_ID            : out LONGWORD_UNSIGNED; 
  497.    FILESPEC, DEFAULT_FILESPEC : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  498.    RESULTANT_FILESPEC         : out CHAR_STRING; 
  499.    RECALL_SIZE                : in BYTE_UNSIGNED := BYTE_UNSIGNED'NULL_PARAMETER
  500.      ); 
  501.  
  502.   procedure CREATE_VIRTUAL_KEYBOARD_1 --
  503.   (NEW_KEYBOARD_ID            : out LONGWORD_UNSIGNED; 
  504.    FILESPEC, DEFAULT_FILESPEC : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  505.    RECALL_SIZE                : in BYTE_UNSIGNED := BYTE_UNSIGNED'NULL_PARAMETER
  506.      ); 
  507.  
  508.   procedure CREATE_VIRTUAL_KEYBOARD_1 --
  509.   (STATUS                     : out COND_VALUE; 
  510.    NEW_KEYBOARD_ID            : out LONGWORD_UNSIGNED; 
  511.    FILESPEC, DEFAULT_FILESPEC : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  512.    RECALL_SIZE                : in BYTE_UNSIGNED := BYTE_UNSIGNED'NULL_PARAMETER
  513.      ); 
  514.  
  515.   pragma INTERFACE(RTL, CREATE_VIRTUAL_KEYBOARD); 
  516.  
  517.   pragma INTERFACE(RTL, CREATE_VIRTUAL_KEYBOARD_1); 
  518.  
  519.   pragma IMPORT_PROCEDURE(CREATE_VIRTUAL_KEYBOARD, "SMG$CREATE_VIRTUAL_KEYBOARD"
  520.     , (LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, CHAR_STRING, BYTE_UNSIGNED))
  521.     ; 
  522.  
  523.   pragma IMPORT_PROCEDURE(CREATE_VIRTUAL_KEYBOARD, "SMG$CREATE_VIRTUAL_KEYBOARD"
  524.     , (COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, CHAR_STRING, 
  525.     BYTE_UNSIGNED)); 
  526.  
  527.   pragma IMPORT_PROCEDURE(CREATE_VIRTUAL_KEYBOARD_1, 
  528.     "SMG$CREATE_VIRTUAL_KEYBOARD", (LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING
  529.     , BYTE_UNSIGNED)); 
  530.  
  531.   pragma IMPORT_PROCEDURE(CREATE_VIRTUAL_KEYBOARD_1, 
  532.     "SMG$CREATE_VIRTUAL_KEYBOARD", (COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, 
  533.     CHAR_STRING, BYTE_UNSIGNED)); 
  534.  
  535.   --------------------------------------------------------------------------
  536.   --------------------------------------------------------------------------
  537.   --    returns the virtual cursor's current column position in a specified
  538.   --    virtual display.
  539.   --  
  540.  
  541.   function CURSOR_COLUMN --
  542.   (DISPLAY_ID : in LONGWORD_UNSIGNED) return LONGWORD_SIGNED; 
  543.  
  544.   pragma INTERFACE(RTL, CURSOR_COLUMN); 
  545.  
  546.   pragma IMPORT_FUNCTION(CURSOR_COLUMN, "SMG$CURSOR_COLUMN"); 
  547.  
  548.   --------------------------------------------------------------------------
  549.   --------------------------------------------------------------------------
  550.   --    returns the virtual cursor's current row position in a specified
  551.   --    virtual display.
  552.   --
  553.  
  554.   function CURSOR_ROW --
  555.   (DISPLAY_ID : in LONGWORD_UNSIGNED) return LONGWORD_SIGNED; 
  556.  
  557.   pragma INTERFACE(RTL, CURSOR_ROW); 
  558.  
  559.   pragma IMPORT_FUNCTION(CURSOR_ROW, "SMG$CURSOR_ROW"); 
  560.  
  561.   --------------------------------------------------------------------------
  562.   --------------------------------------------------------------------------
  563.   --    perform the DEFINE/KEY command you provide.
  564.   -- 
  565.  
  566.   procedure DEFINE_KEY --
  567.   (KEY_TABLE_ID : in LONGWORD_UNSIGNED; 
  568.    COMMAND_LINE : in CHAR_STRING); 
  569.  
  570.   procedure DEFINE_KEY --
  571.   (STATUS       : out COND_VALUE; 
  572.    KEY_TABLE_ID : in LONGWORD_UNSIGNED; 
  573.    COMMAND_LINE : in CHAR_STRING); 
  574.  
  575.   pragma INTERFACE(RTL, DEFINE_KEY); 
  576.  
  577.   pragma IMPORT_PROCEDURE(DEFINE_KEY, "SMG$DEFINE_KEY", (LONGWORD_UNSIGNED, 
  578.     CHAR_STRING)); 
  579.  
  580.   pragma IMPORT_PROCEDURE(DEFINE_KEY, "SMG$DEFINE_KEY", (COND_VALUE, 
  581.     LONGWORD_UNSIGNED, CHAR_STRING)); 
  582.  
  583.   --------------------------------------------------------------------------
  584.   --------------------------------------------------------------------------
  585.   --    terminates access to TERMTABLE.EXE and frees the associated virtual
  586.   --    address space.
  587.   --    
  588.  
  589.   procedure DEL_TERM_TABLE; 
  590.  
  591.   procedure DEL_TERM_TABLE --
  592.   (STATUS : out COND_VALUE); 
  593.  
  594.   pragma INTERFACE(RTL, DEL_TERM_TABLE); 
  595.  
  596.   pragma IMPORT_PROCEDURE(DEL_TERM_TABLE, "SMG$DEL_TERM_TABLE", (null)); 
  597.  
  598.   pragma IMPORT_PROCEDURE(DEL_TERM_TABLE, "SMG$DEL_TERM_TABLE", (COND_VALUE)); 
  599.  
  600.   --------------------------------------------------------------------------
  601.   --------------------------------------------------------------------------
  602.   --    deletes characters in a virtual display.
  603.   --  
  604.  
  605.   procedure DELETE_CHARS --
  606.   (DISPLAY_ID               : in LONGWORD_UNSIGNED; 
  607.    NUM_CHARS, ROWS, COLUMNS : in LONGWORD_SIGNED); 
  608.  
  609.   procedure DELETE_CHARS --
  610.   (STATUS                   : out COND_VALUE; 
  611.    DISPLAY_ID               : in LONGWORD_UNSIGNED; 
  612.    NUM_CHARS, ROWS, COLUMNS : in LONGWORD_SIGNED); 
  613.  
  614.   pragma INTERFACE(RTL, DELETE_CHARS); 
  615.  
  616.   pragma IMPORT_PROCEDURE(DELETE_CHARS, "SMG$DELETE_CHARS", (LONGWORD_UNSIGNED, 
  617.     LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  618.  
  619.   pragma IMPORT_PROCEDURE(DELETE_CHARS, "SMG$DELETE_CHARS", (COND_VALUE, 
  620.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  621.  
  622.   --------------------------------------------------------------------------
  623.   --------------------------------------------------------------------------
  624.   --    deletes a key definition from a specified table of key definitions.
  625.   --   
  626.  
  627.   procedure DELETE_KEY_DEF --
  628.   (KEY_TABLE_ID : in LONGWORD_UNSIGNED; 
  629.    KEY_NAME     : in CHAR_STRING; 
  630.    IF_STATE     : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER); 
  631.  
  632.   procedure DELETE_KEY_DEF --
  633.   (STATUS       : out COND_VALUE; 
  634.    KEY_TABLE_ID : in LONGWORD_UNSIGNED; 
  635.    KEY_NAME     : in CHAR_STRING; 
  636.    IF_STATE     : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER); 
  637.  
  638.   pragma INTERFACE(RTL, DELETE_KEY_DEF); 
  639.  
  640.   pragma IMPORT_PROCEDURE(DELETE_KEY_DEF, "SMG$DELETE_KEY_DEF", (
  641.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING)); 
  642.  
  643.   pragma IMPORT_PROCEDURE(DELETE_KEY_DEF, "SMG$DELETE_KEY_DEF", (COND_VALUE, 
  644.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING)); 
  645.  
  646.   --------------------------------------------------------------------------
  647.   --------------------------------------------------------------------------
  648.   --    deletes lines from a virtual display.
  649.   --   
  650.  
  651.   procedure DELETE_LINE --
  652.   (DISPLAY_ID   : in LONGWORD_UNSIGNED; 
  653.    START_LINE   : in LONGWORD_SIGNED; 
  654.    NUMBER_LINES : in LONGWORD_SIGNED := LONGWORD_SIGNED'NULL_PARAMETER); 
  655.  
  656.   procedure DELETE_LINE --
  657.   (STATUS       : out COND_VALUE; 
  658.    DISPLAY_ID   : in LONGWORD_UNSIGNED; 
  659.    START_LINE   : in LONGWORD_SIGNED; 
  660.    NUMBER_LINES : in LONGWORD_SIGNED := LONGWORD_SIGNED'NULL_PARAMETER); 
  661.  
  662.   pragma INTERFACE(RTL, DELETE_LINE); 
  663.  
  664.   pragma IMPORT_PROCEDURE(DELETE_LINE, "SMG$DELETE_LINE", (LONGWORD_UNSIGNED, 
  665.     LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  666.  
  667.   pragma IMPORT_PROCEDURE(DELETE_LINE, "SMG$DELETE_LINE", (COND_VALUE, 
  668.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  669.  
  670.   --------------------------------------------------------------------------
  671.   --------------------------------------------------------------------------
  672.   --    flushes all output to the display, terminates all use for the specified
  673.   --    pasteboard, and deallocates all resources associated with the 
  674.   --    pasteboard.
  675.   --   
  676.  
  677.   procedure DELETE_PASTEBOARD --
  678.   (PASTEBOARD_ID     : in LONGWORD_UNSIGNED; 
  679.    CLEAR_SCREEN_FLAG : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER); 
  680.  
  681.   procedure DELETE_PASTEBOARD --
  682.   (STATUS            : out COND_VALUE; 
  683.    PASTEBOARD_ID     : in LONGWORD_UNSIGNED; 
  684.    CLEAR_SCREEN_FLAG : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER); 
  685.  
  686.   pragma INTERFACE(RTL, DELETE_PASTEBOARD); 
  687.  
  688.   pragma IMPORT_PROCEDURE(DELETE_PASTEBOARD, "SMG$DELETE_PASTEBOARD", (
  689.     LONGWORD_UNSIGNED, MASK_LONGWORD)); 
  690.  
  691.   pragma IMPORT_PROCEDURE(DELETE_PASTEBOARD, "SMG$DELETE_PASTEBOARD", (
  692.     COND_VALUE, LONGWORD_UNSIGNED, MASK_LONGWORD)); 
  693.  
  694.   --------------------------------------------------------------------------
  695.   --------------------------------------------------------------------------
  696.   --    deletes a virtual display and removes it from any pasteboard on which
  697.   --    it is pasted.  It also deallocates any buffer space associated with
  698.   --    the virtual display.
  699.   --  
  700.  
  701.   procedure DELETE_VIRTUAL_DISPLAY --
  702.   (DISPLAY_ID : in LONGWORD_UNSIGNED); 
  703.  
  704.   procedure DELETE_VIRTUAL_DISPLAY --
  705.   (STATUS     : out COND_VALUE; 
  706.    DISPLAY_ID : in LONGWORD_UNSIGNED); 
  707.  
  708.   pragma INTERFACE(RTL, DELETE_VIRTUAL_DISPLAY); 
  709.  
  710.   pragma IMPORT_PROCEDURE(DELETE_VIRTUAL_DISPLAY, "SMG$DELETE_VIRTUAL_DISPLAY", 
  711.     (LONGWORD_UNSIGNED)); 
  712.  
  713.   pragma IMPORT_PROCEDURE(DELETE_VIRTUAL_DISPLAY, "SMG$DELETE_VIRTUAL_DISPLAY", 
  714.     (COND_VALUE, LONGWORD_UNSIGNED)); 
  715.  
  716.   --------------------------------------------------------------------------
  717.   --------------------------------------------------------------------------
  718.   --    deletes a virtual keyboard.  Any terminal attributes specified when 
  719.   --    the keyboard was created are reset to their previous values and the
  720.   --    keypad mode (numeric or application) is reset to its original state.
  721.   --    In addition, the channel is deassigned and, if the virtual keyboard
  722.   --    was a file, the file is closed.
  723.   --   
  724.  
  725.   procedure DELETE_VIRTUAL_KEYBOARD --
  726.   (KEYBOARD_ID : in LONGWORD_UNSIGNED); 
  727.  
  728.   procedure DELETE_VIRTUAL_KEYBOARD --
  729.   (STATUS      : out COND_VALUE; 
  730.    KEYBOARD_ID : in LONGWORD_UNSIGNED); 
  731.  
  732.   pragma INTERFACE(RTL, DELETE_VIRTUAL_KEYBOARD); 
  733.  
  734.   pragma IMPORT_PROCEDURE(DELETE_VIRTUAL_KEYBOARD, "SMG$DELETE_VIRTUAL_KEYBOARD"
  735.     , (LONGWORD_UNSIGNED)); 
  736.  
  737.   pragma IMPORT_PROCEDURE(DELETE_VIRTUAL_KEYBOARD, "SMG$DELETE_VIRTUAL_KEYBOARD"
  738.     , (COND_VALUE, LONGWORD_UNSIGNED)); 
  739.  
  740.   --------------------------------------------------------------------------
  741.   --------------------------------------------------------------------------
  742.   --    disables trapping of broadcast messages for the specified terminal.
  743.   --     
  744.  
  745.   procedure DISABLE_BROADCAST_TRAPPING --
  746.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  747.  
  748.   procedure DISABLE_BROADCAST_TRAPPING --
  749.   (STATUS        : out COND_VALUE; 
  750.    PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  751.  
  752.   pragma INTERFACE(RTL, DISABLE_BROADCAST_TRAPPING); 
  753.  
  754.   pragma IMPORT_PROCEDURE(DISABLE_BROADCAST_TRAPPING, 
  755.     "SMG$DISABLE_BROADCAST_TRAPPING", (LONGWORD_UNSIGNED)); 
  756.  
  757.   pragma IMPORT_PROCEDURE(DISABLE_BROADCAST_TRAPPING, 
  758.     "SMG$DISABLE_BROADCAST_TRAPPING", (COND_VALUE, LONGWORD_UNSIGNED)); 
  759.  
  760.   --------------------------------------------------------------------------
  761.   --------------------------------------------------------------------------
  762.   --    disables the invocation of AST routines for unsolicited input.
  763.   --   
  764.  
  765.   procedure DISABLE_UNSOLICITED_INPUT --
  766.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  767.  
  768.   procedure DISABLE_UNSOLICITED_INPUT --
  769.   (STATUS        : out COND_VALUE; 
  770.    PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  771.  
  772.   pragma INTERFACE(RTL, DISABLE_UNSOLICITED_INPUT); 
  773.  
  774.   pragma IMPORT_PROCEDURE(DISABLE_UNSOLICITED_INPUT, 
  775.     "SMG$DISABLE_UNSOLICITED_INPUT", (LONGWORD_UNSIGNED)); 
  776.  
  777.   pragma IMPORT_PROCEDURE(DISABLE_UNSOLICITED_INPUT, 
  778.     "SMG$DISABLE_UNSOLICITED_INPUT", (COND_VALUE, LONGWORD_UNSIGNED)); 
  779.  
  780.   --------------------------------------------------------------------------
  781.   --------------------------------------------------------------------------
  782.   --    draws a horizontal or vertical line.
  783.   --
  784.  
  785.   procedure DRAW_LINE --
  786.   (DISPLAY_ID                                   : in LONGWORD_UNSIGNED; 
  787.    START_ROW, START_COLUMN, END_ROW, END_COLUMN : in LONGWORD_SIGNED; 
  788.    RENDITION_SET, RENDITION_COMPLEMENT          : in MASK_LONGWORD := 
  789.      MASK_LONGWORD'NULL_PARAMETER); 
  790.  
  791.   procedure DRAW_LINE --
  792.   (STATUS                                       : out COND_VALUE; 
  793.    DISPLAY_ID                                   : in LONGWORD_UNSIGNED; 
  794.    START_ROW, START_COLUMN, END_ROW, END_COLUMN : in LONGWORD_SIGNED; 
  795.    RENDITION_SET, RENDITION_COMPLEMENT          : in MASK_LONGWORD := 
  796.      MASK_LONGWORD'NULL_PARAMETER); 
  797.  
  798.   pragma INTERFACE(RTL, DRAW_LINE); 
  799.  
  800.   pragma IMPORT_PROCEDURE(DRAW_LINE, "SMG$DRAW_LINE", (LONGWORD_UNSIGNED, 
  801.     LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  802.     MASK_LONGWORD, MASK_LONGWORD)); 
  803.  
  804.   pragma IMPORT_PROCEDURE(DRAW_LINE, "SMG$DRAW_LINE", (COND_VALUE, 
  805.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  806.     LONGWORD_SIGNED, MASK_LONGWORD, MASK_LONGWORD)); 
  807.  
  808.   --------------------------------------------------------------------------
  809.   --------------------------------------------------------------------------
  810.   --    draws a rectangle in a virtual display, given the position of the
  811.   --    of the upper left-hand corner and the lower right-hand corner. The
  812.   --    characters used to draw the lines making up the rectangle depend on
  813.   --    the type of terminal.  The virtual cursor position does not change.
  814.   -- 
  815.  
  816.   procedure DRAW_RECTANGLE --
  817.   (DISPLAY_ID                            : in LONGWORD_UNSIGNED; 
  818.    TOP_LEFT_ROW, TOP_LEFT_COLUMN         : in LONGWORD_SIGNED; 
  819.    BOTTOM_RIGHT_ROW, BOTTOM_RIGHT_COLUMN : in LONGWORD_SIGNED; 
  820.    RENDITION_SET, RENDITION_COMPLEMENT   : in MASK_LONGWORD := MASK_LONGWORD'
  821.      NULL_PARAMETER); 
  822.  
  823.   procedure DRAW_RECTANGLE --
  824.   (STATUS                                : out COND_VALUE; 
  825.    DISPLAY_ID                            : in LONGWORD_UNSIGNED; 
  826.    TOP_LEFT_ROW, TOP_LEFT_COLUMN         : in LONGWORD_SIGNED; 
  827.    BOTTOM_RIGHT_ROW, BOTTOM_RIGHT_COLUMN : in LONGWORD_SIGNED; 
  828.    RENDITION_SET, RENDITION_COMPLEMENT   : in MASK_LONGWORD := MASK_LONGWORD'
  829.      NULL_PARAMETER); 
  830.  
  831.   pragma INTERFACE(RTL, DRAW_RECTANGLE); 
  832.  
  833.   pragma IMPORT_PROCEDURE(DRAW_RECTANGLE, "SMG$DRAW_RECTANGLE", (
  834.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  835.     LONGWORD_SIGNED, MASK_LONGWORD, MASK_LONGWORD)); 
  836.  
  837.   pragma IMPORT_PROCEDURE(DRAW_RECTANGLE, "SMG$DRAW_RECTANGLE", (COND_VALUE, 
  838.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  839.     LONGWORD_SIGNED, MASK_LONGWORD, MASK_LONGWORD)); 
  840.  
  841.   --------------------------------------------------------------------------
  842.   -------------------------------------------------------------------------- 
  843.   --    detects unsolicited input and calls an AST routine in response.
  844.   --                                                
  845.  
  846.   procedure ENABLE_UNSOLICITED_INPUT --
  847.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  848.    AST_ROUTINE   : in AST_PROCEDURE; 
  849.    AST_ARGUMENT  : in USER_ARG := USER_ARG'NULL_PARAMETER); 
  850.  
  851.   procedure ENABLE_UNSOLICITED_INPUT --
  852.   (STATUS        : out COND_VALUE; 
  853.    PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  854.    AST_ROUTINE   : in AST_PROCEDURE; 
  855.    AST_ARGUMENT  : in USER_ARG := USER_ARG'NULL_PARAMETER); 
  856.  
  857.   pragma INTERFACE(RTL, ENABLE_UNSOLICITED_INPUT); 
  858.  
  859.   pragma IMPORT_PROCEDURE(ENABLE_UNSOLICITED_INPUT, 
  860.     "SMG$ENABLE_UNSOLICITED_INPUT", (LONGWORD_UNSIGNED, AST_PROCEDURE, USER_ARG)
  861.     ); 
  862.  
  863.   pragma IMPORT_PROCEDURE(ENABLE_UNSOLICITED_INPUT, 
  864.     "SMG$ENABLE_UNSOLICITED_INPUT", (COND_VALUE, LONGWORD_UNSIGNED, 
  865.     AST_PROCEDURE, USER_ARG)); 
  866.  
  867.   --------------------------------------------------------------------------
  868.   --------------------------------------------------------------------------
  869.   --    ends update batching for a virtual display.
  870.   --
  871.  
  872.   procedure END_DISPLAY_UPDATE --
  873.   (DISPLAY_ID : in LONGWORD_UNSIGNED); 
  874.  
  875.   procedure END_DISPLAY_UPDATE --
  876.   (STATUS     : out COND_VALUE; 
  877.    DISPLAY_ID : in LONGWORD_UNSIGNED); 
  878.  
  879.   pragma INTERFACE(RTL, END_DISPLAY_UPDATE); 
  880.  
  881.   pragma IMPORT_PROCEDURE(END_DISPLAY_UPDATE, "SMG$END_DISPLAY_UPDATE", (
  882.     LONGWORD_UNSIGNED)); 
  883.  
  884.   pragma IMPORT_PROCEDURE(END_DISPLAY_UPDATE, "SMG$END_DISPLAY_UPDATE", (
  885.     COND_VALUE, LONGWORD_UNSIGNED)); 
  886.  
  887.   --------------------------------------------------------------------------
  888.   --------------------------------------------------------------------------
  889.   --    ends update batching for a pasteboard.
  890.   --
  891.  
  892.   procedure END_PASTEBOARD_UPDATE --
  893.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  894.  
  895.   procedure END_PASTEBOARD_UPDATE --
  896.   (STATUS        : out COND_VALUE; 
  897.    PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  898.  
  899.   pragma INTERFACE(RTL, END_PASTEBOARD_UPDATE); 
  900.  
  901.   pragma IMPORT_PROCEDURE(END_PASTEBOARD_UPDATE, "SMG$END_PASTEBOARD_UPDATE", (
  902.     LONGWORD_UNSIGNED)); 
  903.  
  904.   pragma IMPORT_PROCEDURE(END_PASTEBOARD_UPDATE, "SMG$END_PASTEBOARD_UPDATE", (
  905.     COND_VALUE, LONGWORD_UNSIGNED)); 
  906.  
  907.   --------------------------------------------------------------------------
  908.   --------------------------------------------------------------------------
  909.   --    erases characters in a virtual display by replacing them with blanks.
  910.   --
  911.  
  912.   procedure ERASE_CHARS --
  913.   (DISPLAY_ID                                 : in LONGWORD_UNSIGNED; 
  914.    NUMBER_OF_CHARS, ROW_NUMBER, COLUMN_NUMBER : in LONGWORD_SIGNED); 
  915.  
  916.   procedure ERASE_CHARS --
  917.   (STATUS                                     : out COND_VALUE; 
  918.    DISPLAY_ID                                 : in LONGWORD_UNSIGNED; 
  919.    NUMBER_OF_CHARS, ROW_NUMBER, COLUMN_NUMBER : in LONGWORD_SIGNED); 
  920.  
  921.   pragma INTERFACE(RTL, ERASE_CHARS); 
  922.  
  923.   pragma IMPORT_PROCEDURE(ERASE_CHARS, "SMG$ERASE_CHARS", (LONGWORD_UNSIGNED, 
  924.     LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  925.  
  926.   pragma IMPORT_PROCEDURE(ERASE_CHARS, "SMG$ERASE_CHARS", (COND_VALUE, 
  927.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  928.  
  929.   --------------------------------------------------------------------------
  930.   --------------------------------------------------------------------------
  931.   --    causes all or part of a virtual display to be erased by replacing
  932.   --    text characters with blanks.  If omitted, the starting position
  933.   --    default to 1,1. The ending positions default to the last row or
  934.   --    column in the display.  thus, to erase the entire virtual, you 
  935.   --    need only pass the display-id.  The cursor position is the first
  936.   --    free position after the erased portion.  If the entire is erased,
  937.   --    the virtual cursor is left at position 1,1.
  938.   --
  939.  
  940.   procedure ERASE_DISPLAY --
  941.   (DISPLAY_ID                                   : in LONGWORD_UNSIGNED; 
  942.    START_ROW, START_COLUMN, END_ROW, END_COLUMN : in LONGWORD_SIGNED := 
  943.      LONGWORD_SIGNED'NULL_PARAMETER); 
  944.  
  945.   procedure ERASE_DISPLAY --
  946.   (STATUS                                       : out COND_VALUE; 
  947.    DISPLAY_ID                                   : in LONGWORD_UNSIGNED; 
  948.    START_ROW, START_COLUMN, END_ROW, END_COLUMN : in LONGWORD_SIGNED := 
  949.      LONGWORD_SIGNED'NULL_PARAMETER); 
  950.  
  951.   pragma INTERFACE(RTL, ERASE_DISPLAY); 
  952.  
  953.   pragma IMPORT_PROCEDURE(ERASE_DISPLAY, "SMG$ERASE_DISPLAY", (LONGWORD_UNSIGNED
  954.     , LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  955.  
  956.   pragma IMPORT_PROCEDURE(ERASE_DISPLAY, "SMG$ERASE_DISPLAY", (COND_VALUE, 
  957.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  958.     LONGWORD_SIGNED)); 
  959.  
  960.   --------------------------------------------------------------------------
  961.   --------------------------------------------------------------------------
  962.   --    erases a line from the specified starting porition to the end of
  963.   --    the line.  If you do not specify a starting position, SMG$ERASE_LINE
  964.   --    erases text form the current virtual cursor position to the end of 
  965.   --    the line.  The virtual cursor remains at the first blank position
  966.   --    after the erased text.
  967.   --
  968.  
  969.   procedure ERASE_LINE --
  970.   (DISPLAY_ID                 : in LONGWORD_UNSIGNED; 
  971.    LINE_NUMBER, COLUMN_NUMBER : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  972.      NULL_PARAMETER); 
  973.  
  974.   procedure ERASE_LINE --
  975.   (STATUS                     : out COND_VALUE; 
  976.    DISPLAY_ID                 : in LONGWORD_UNSIGNED; 
  977.    LINE_NUMBER, COLUMN_NUMBER : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  978.      NULL_PARAMETER); 
  979.  
  980.   pragma INTERFACE(RTL, ERASE_LINE); 
  981.  
  982.   pragma IMPORT_PROCEDURE(ERASE_LINE, "SMG$ERASE_LINE", (LONGWORD_UNSIGNED, 
  983.     LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  984.  
  985.   pragma IMPORT_PROCEDURE(ERASE_LINE, "SMG$ERASE_LINE", (COND_VALUE, 
  986.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  987.  
  988.   --------------------------------------------------------------------------
  989.   --------------------------------------------------------------------------
  990.   --    erases the specified pasteboard.  The physical cursor is left at       
  991.   --    position 1,1.  If there are any virtual displays pasted to the
  992.   --    pasteboard, they will be redrawn the next time the Screen Management
  993.   --    Facility is used to output the pasteboard.                
  994.   --
  995.  
  996.   procedure ERASE_PASTEBOARD --
  997.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  998.  
  999.   procedure ERASE_PASTEBOARD --
  1000.   (STATUS        : out COND_VALUE; 
  1001.    PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  1002.  
  1003.   pragma INTERFACE(RTL, ERASE_PASTEBOARD); 
  1004.  
  1005.   pragma IMPORT_PROCEDURE(ERASE_PASTEBOARD, "SMG$ERASE_PASTEBOARD", (
  1006.     LONGWORD_UNSIGNED)); 
  1007.  
  1008.   pragma IMPORT_PROCEDURE(ERASE_PASTEBOARD, "SMG$ERASE_PASTEBOARD", (COND_VALUE
  1009.     , LONGWORD_UNSIGNED)); 
  1010.  
  1011.   --------------------------------------------------------------------------
  1012.   --------------------------------------------------------------------------
  1013.   --    determines which virtual display contains the physical cursor on
  1014.   --    a specified pasteboard, and returns the virtual display's inden-
  1015.   --    tifier. SMG$FIND_CURSOR_DISPLAY  returns the display-id of the 
  1016.   --    most recently pasted virtual display  which contains the physical 
  1017.   --    cursor. If no virtual display contains the physical cursor, this
  1018.   --    routine returns a 0, which is an invalid display identifier.
  1019.   --
  1020.  
  1021.   procedure FIND_CURSOR_DISPLAY --
  1022.   (PASTEBOARD_ID       : in LONGWORD_UNSIGNED; 
  1023.    RETURNED_DISPLAY_ID : out LONGWORD_UNSIGNED); 
  1024.  
  1025.   procedure FIND_CURSOR_DISPLAY --
  1026.   (STATUS              : out COND_VALUE; 
  1027.    PASTEBOARD_ID       : in LONGWORD_UNSIGNED; 
  1028.    RETURNED_DISPLAY_ID : out LONGWORD_UNSIGNED); 
  1029.  
  1030.   pragma INTERFACE(RTL, FIND_CURSOR_DISPLAY); 
  1031.  
  1032.   pragma IMPORT_PROCEDURE(FIND_CURSOR_DISPLAY, "SMG$FIND_CURSOR_DISPLAY", (
  1033.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1034.  
  1035.   pragma IMPORT_PROCEDURE(FIND_CURSOR_DISPLAY, "SMG$FIND_CURSOR_DISPLAY", (
  1036.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1037.  
  1038.   --------------------------------------------------------------------------
  1039.   --------------------------------------------------------------------------
  1040.   --    causes all buffered output to be sent to the terminal immediately.
  1041.   --    The calling program would normally call this routine just before
  1042.   --    performing some cpu-intensive calculations, or whenever the terminal
  1043.   --    screen must be up-to-date.
  1044.   --    
  1045.  
  1046.   procedure FLUSH_BUFFER --
  1047.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  1048.  
  1049.   procedure FLUSH_BUFFER --
  1050.   (STATUS        : out COND_VALUE; 
  1051.    PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  1052.  
  1053.   pragma INTERFACE(RTL, FLUSH_BUFFER); 
  1054.  
  1055.   pragma IMPORT_PROCEDURE(FLUSH_BUFFER, "SMG$FLUSH_BUFFER", (LONGWORD_UNSIGNED))
  1056.     ; 
  1057.  
  1058.   pragma IMPORT_PROCEDURE(FLUSH_BUFFER, "SMG$FLUSH_BUFFER", (COND_VALUE, 
  1059.     LONGWORD_UNSIGNED)); 
  1060.  
  1061.   --------------------------------------------------------------------------
  1062.   --------------------------------------------------------------------------
  1063.   --    determines whether a message has been broadcast to the pasteboard
  1064.   --    and returns the message.
  1065.   --   
  1066.  
  1067.   procedure GET_BROADCAST_MESSAGE --
  1068.   (PASTEBOARD_ID  : in LONGWORD_UNSIGNED; 
  1069.    MESSAGE        : out CHAR_STRING; 
  1070.    MESSAGE_LENGTH : out WORD_SIGNED); 
  1071.  
  1072.   procedure GET_BROADCAST_MESSAGE --
  1073.   (STATUS         : out COND_VALUE; 
  1074.    PASTEBOARD_ID  : in LONGWORD_UNSIGNED; 
  1075.    MESSAGE        : out CHAR_STRING; 
  1076.    MESSAGE_LENGTH : out WORD_SIGNED); 
  1077.  
  1078.   pragma INTERFACE(RTL, GET_BROADCAST_MESSAGE); 
  1079.  
  1080.   pragma IMPORT_PROCEDURE(GET_BROADCAST_MESSAGE, "SMG$GET_BROADCAST_MESSAGE", (
  1081.     LONGWORD_UNSIGNED, CHAR_STRING, WORD_SIGNED)); 
  1082.  
  1083.   pragma IMPORT_PROCEDURE(GET_BROADCAST_MESSAGE, "SMG$GET_BROADCAST_MESSAGE", (
  1084.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, WORD_SIGNED)); 
  1085.  
  1086.   --------------------------------------------------------------------------
  1087.   --------------------------------------------------------------------------
  1088.   --    returns the character at the current physical cursor postion.
  1089.   --
  1090.  
  1091.   procedure GET_CHAR_AT_PHYSICAL_CURSOR --
  1092.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  1093.    CHARACTER     : out BYTE_UNSIGNED); 
  1094.  
  1095.   procedure GET_CHAR_AT_PHYSICAL_CURSOR --
  1096.   (STATUS        : out COND_VALUE; 
  1097.    PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  1098.    CHARACTER     : out BYTE_UNSIGNED); 
  1099.  
  1100.   pragma INTERFACE(RTL, GET_CHAR_AT_PHYSICAL_CURSOR); 
  1101.  
  1102.   pragma IMPORT_PROCEDURE(GET_CHAR_AT_PHYSICAL_CURSOR, 
  1103.     "SMG$GET_CHAR_AT_PHYSICAL_CURSOR", (LONGWORD_UNSIGNED, BYTE_UNSIGNED)); 
  1104.  
  1105.   pragma IMPORT_PROCEDURE(GET_CHAR_AT_PHYSICAL_CURSOR, 
  1106.     "SMG$GET_CHAR_AT_PHYSICAL_CURSOR", (COND_VALUE, LONGWORD_UNSIGNED, 
  1107.     BYTE_UNSIGNED)); 
  1108.  
  1109.   --------------------------------------------------------------------------
  1110.   --------------------------------------------------------------------------
  1111.   --    returns attributes associated with a virtual display.
  1112.   --
  1113.  
  1114.   procedure GET_DISPLAY_ATTR --
  1115.   (DISPLAY_ID                           : in LONGWORD_UNSIGNED; 
  1116.    HEIGHT, WIDTH                        : out LONGWORD_SIGNED; 
  1117.    DISPLAY_ATTRIBUTES, VIDEO_ATTRIBUTES : out LONGWORD_UNSIGNED; 
  1118.    CHAR_SET                             : in LONGWORD_UNSIGNED); 
  1119.  
  1120.   procedure GET_DISPLAY_ATTR --
  1121.   (STATUS                               : out COND_VALUE; 
  1122.    DISPLAY_ID                           : in LONGWORD_UNSIGNED; 
  1123.    HEIGHT, WIDTH                        : out LONGWORD_SIGNED; 
  1124.    DISPLAY_ATTRIBUTES, VIDEO_ATTRIBUTES : out LONGWORD_UNSIGNED; 
  1125.    CHAR_SET                             : in LONGWORD_UNSIGNED); 
  1126.  
  1127.   pragma INTERFACE(RTL, GET_DISPLAY_ATTR); 
  1128.  
  1129.   pragma IMPORT_PROCEDURE(GET_DISPLAY_ATTR, "SMG$GET_DISPLAY_ATTR", (
  1130.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_UNSIGNED, 
  1131.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1132.  
  1133.   pragma IMPORT_PROCEDURE(GET_DISPLAY_ATTR, "SMG$GET_DISPLAY_ATTR", (COND_VALUE
  1134.     , LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_UNSIGNED, 
  1135.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1136.  
  1137.   --------------------------------------------------------------------------
  1138.   --------------------------------------------------------------------------
  1139.   --    returns the key definition for a specified key.
  1140.   --
  1141.  
  1142.   procedure GET_KEY_DEF --
  1143.   (KEYBOARD_ID  : in LONGWORD_UNSIGNED; 
  1144.    KEY_NAME     : in CHAR_STRING; 
  1145.    IF_STATE     : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  1146.    ATTRIBUTES   : out MASK_LONGWORD; 
  1147.    EQUIV_STRING : out CHAR_STRING; 
  1148.    STATE_STRING : out CHAR_STRING); 
  1149.  
  1150.   procedure GET_KEY_DEF --
  1151.   (STATUS       : out COND_VALUE; 
  1152.    KEYBOARD_ID  : in LONGWORD_UNSIGNED; 
  1153.    KEY_NAME     : in CHAR_STRING; 
  1154.    IF_STATE     : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  1155.    ATTRIBUTES   : out MASK_LONGWORD; 
  1156.    EQUIV_STRING : out CHAR_STRING; 
  1157.    STATE_STRING : out CHAR_STRING); 
  1158.  
  1159.   procedure GET_KEY_DEF --
  1160.   (KEYBOARD_ID : in LONGWORD_UNSIGNED; 
  1161.    KEY_NAME    : in CHAR_STRING; 
  1162.    IF_STATE    : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER); 
  1163.  
  1164.   procedure GET_KEY_DEF --
  1165.   (STATYS      : out COND_VALUE; 
  1166.    KEYBOARD_ID : in LONGWORD_UNSIGNED; 
  1167.    KEY_NAME    : in CHAR_STRING; 
  1168.    IF_STATE    : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER); 
  1169.  
  1170.   pragma INTERFACE(RTL, GET_KEY_DEF); 
  1171.  
  1172.   pragma IMPORT_PROCEDURE(GET_KEY_DEF, "SMG$GET_KEY_DEF", (LONGWORD_UNSIGNED, 
  1173.     CHAR_STRING, CHAR_STRING, MASK_LONGWORD, CHAR_STRING, CHAR_STRING)); 
  1174.  
  1175.   pragma IMPORT_PROCEDURE(GET_KEY_DEF, "SMG$GET_KEY_DEF", (COND_VALUE, 
  1176.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, MASK_LONGWORD, CHAR_STRING, 
  1177.     CHAR_STRING)); 
  1178.  
  1179.   pragma IMPORT_PROCEDURE(GET_KEY_DEF, "SMG$GET_KEY_DEF", (LONGWORD_UNSIGNED, 
  1180.     CHAR_STRING, CHAR_STRING)); 
  1181.  
  1182.   pragma IMPORT_PROCEDURE(GET_KEY_DEF, "SMG$GET_KEY_DEF", (COND_VALUE, 
  1183.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING)); 
  1184.  
  1185.   --------------------------------------------------------------------------
  1186.   --------------------------------------------------------------------------
  1187.   --    gets information about a virtual keyboard and leaves it in a 
  1188.   --    user-supplied area: the keyboard information table(KIT).
  1189.   --
  1190.  
  1191.   procedure GET_KEYBOARD_ATTRIBUTES --
  1192.   (KEYBOARD_ID       : in LONGWORD_UNSIGNED; 
  1193.    P_KIT, P_KIT_SIZE : out LONGWORD_UNSIGNED); 
  1194.  
  1195.   procedure GET_KEYBOARD_ATTRIBUTES --
  1196.   (STATUS            : out COND_VALUE; 
  1197.    KEYBOARD_ID       : in LONGWORD_UNSIGNED; 
  1198.    P_KIT, P_KIT_SIZE : out LONGWORD_UNSIGNED); 
  1199.  
  1200.   pragma INTERFACE(RTL, GET_KEYBOARD_ATTRIBUTES); 
  1201.  
  1202.   pragma IMPORT_PROCEDURE(GET_KEYBOARD_ATTRIBUTES, "SMG$GET_KEYBOARD_ATTRIBUTES"
  1203.     , (LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1204.  
  1205.   pragma IMPORT_PROCEDURE(GET_KEYBOARD_ATTRIBUTES, "SMG$GET_KEYBOARD_ATTRIBUTES"
  1206.     , (COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1207.  
  1208.   --------------------------------------------------------------------------
  1209.   --------------------------------------------------------------------------
  1210.   --    accesses TERMTABLE.EXE and returns the numeric sequence that causes
  1211.   --    a terminal to perform a specified operation.
  1212.   -- 
  1213.  
  1214.   procedure GET_NUMERIC_DATA --
  1215.   (TERMTABLE_ADDRESS : in LONGWORD_UNSIGNED; 
  1216.    REQUEST_CODE      : in LONGWORD_SIGNED; 
  1217.    BUFFER_ADDRESS    : out LONGWORD_UNSIGNED); 
  1218.  
  1219.   procedure GET_NUMERIC_DATA --
  1220.   (STATUS            : out COND_VALUE; 
  1221.    TERMTABLE_ADDRESS : in LONGWORD_UNSIGNED; 
  1222.    REQUEST_CODE      : in LONGWORD_SIGNED; 
  1223.    BUFFER_ADDRESS    : out LONGWORD_UNSIGNED); 
  1224.  
  1225.   pragma INTERFACE(RTL, GET_NUMERIC_DATA); 
  1226.  
  1227.   pragma IMPORT_PROCEDURE(GET_NUMERIC_DATA, "SMG$GET_NUMERIC_DATA", (
  1228.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_UNSIGNED)); 
  1229.  
  1230.   pragma IMPORT_PROCEDURE(GET_NUMERIC_DATA, "SMG$GET_NUMERIC_DATA", (COND_VALUE
  1231.     , LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_UNSIGNED)); 
  1232.  
  1233.   --------------------------------------------------------------------------
  1234.   --------------------------------------------------------------------------
  1235.   --    provided that the specified virtual display is currently pasted,
  1236.   --    the row and column of the pasting are returned.
  1237.   --
  1238.  
  1239.   procedure GET_PASTING_INFO --
  1240.   (DISPLAY_ID                     : in LONGWORD_UNSIGNED; 
  1241.    PASTEBOARD_ID                  : in LONGWORD_UNSIGNED; 
  1242.    PASTED_FLAG                    : out BOOLEAN; 
  1243.    PASTEBOARD_ROW, PASTEBOARD_COL : out LONGWORD_SIGNED); 
  1244.  
  1245.   procedure GET_PASTING_INFO --
  1246.   (STATUS                         : out COND_VALUE; 
  1247.    DISPLAY_ID                     : in LONGWORD_UNSIGNED; 
  1248.    PASTEBOARD_ID                  : in LONGWORD_UNSIGNED; 
  1249.    PASTED_FLAG                    : out BOOLEAN; 
  1250.    PASTEBOARD_ROW, PASTEBOARD_COL : out LONGWORD_SIGNED); 
  1251.  
  1252.   procedure GET_PASTING_INFO_1 --
  1253.   (DISPLAY_ID    : in LONGWORD_UNSIGNED; 
  1254.    PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  1255.    PASTED_FLAG   : out BOOLEAN); 
  1256.  
  1257.   procedure GET_PASTING_INFO_1 --
  1258.   (STATUS        : out COND_VALUE; 
  1259.    DISPLAY_ID    : in LONGWORD_UNSIGNED; 
  1260.    PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  1261.    PASTED_FLAG   : out BOOLEAN); 
  1262.  
  1263.   pragma INTERFACE(RTL, GET_PASTING_INFO); 
  1264.  
  1265.   pragma INTERFACE(RTL, GET_PASTING_INFO_1); 
  1266.  
  1267.   pragma IMPORT_PROCEDURE(GET_PASTING_INFO, "SMG$GET_PASTING_INFO", (
  1268.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, BOOLEAN, LONGWORD_SIGNED, 
  1269.     LONGWORD_SIGNED)); 
  1270.  
  1271.   pragma IMPORT_PROCEDURE(GET_PASTING_INFO, "SMG$GET_PASTING_INFO", (COND_VALUE
  1272.     , LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, BOOLEAN, LONGWORD_SIGNED, 
  1273.     LONGWORD_SIGNED)); 
  1274.  
  1275.   pragma IMPORT_PROCEDURE(GET_PASTING_INFO_1, "SMG$GET_PASTING_INFO", (
  1276.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, BOOLEAN)); 
  1277.  
  1278.   pragma IMPORT_PROCEDURE(GET_PASTING_INFO_1, "SMG$GET_PASTING_INFO", (
  1279.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, BOOLEAN)); 
  1280.  
  1281.   --------------------------------------------------------------------------
  1282.   --------------------------------------------------------------------------
  1283.   --    gets pasteboard attributes and stores them in the pasteboard 
  1284.   --    information table.
  1285.   --
  1286.  
  1287.   procedure GET_PASTEBOARD_ATTRIBUTES --
  1288.   (PASTEBOARD_ID      : in LONGWORD_UNSIGNED; 
  1289.    PB_INFO_TABLE      : out VECTOR_BYTE_UNSIGNED; 
  1290.    PB_INFO_TABLE_SIZE : out LONGWORD_UNSIGNED); 
  1291.  
  1292.   procedure GET_PASTEBOARD_ATTRIBUTES --
  1293.   (STATUS             : out COND_VALUE; 
  1294.    PASTEBOARD_ID      : in LONGWORD_UNSIGNED; 
  1295.    PB_INFO_TABLE      : out VECTOR_BYTE_UNSIGNED; 
  1296.    PB_INFO_TABLE_SIZE : out LONGWORD_UNSIGNED); 
  1297.  
  1298.   pragma INTERFACE(RTL, GET_PASTEBOARD_ATTRIBUTES); 
  1299.  
  1300.   pragma IMPORT_PROCEDURE(GET_PASTEBOARD_ATTRIBUTES, 
  1301.     "SMG$GET_PASTEBOARD_ATTRIBUTES", (LONGWORD_UNSIGNED, VECTOR_BYTE_UNSIGNED, 
  1302.     LONGWORD_UNSIGNED)); 
  1303.  
  1304.   pragma IMPORT_PROCEDURE(GET_PASTEBOARD_ATTRIBUTES, 
  1305.     "SMG$GET_PASTEBOARD_ATTRIBUTES", (COND_VALUE, LONGWORD_UNSIGNED, 
  1306.     VECTOR_BYTE_UNSIGNED, LONGWORD_UNSIGNED)); 
  1307.  
  1308.   --------------------------------------------------------------------------
  1309.   --------------------------------------------------------------------------
  1310.   --    accesses TERMTABLE.EXE and returns the character sequence that 
  1311.   --    causes a terminal to perform a specified operation.
  1312.   --
  1313.  
  1314.   procedure GET_TERM_DATA --
  1315.   (TERMTABLE_ADDRESS, REQUEST_CODE : in LONGWORD_SIGNED; 
  1316.    MAX_BUFFER_LENGTH               : in LONGWORD_SIGNED; 
  1317.    RETURN_LENGTH                   : out LONGWORD_SIGNED; 
  1318.    BUFFER_ADDRESS                  : out LONGWORD_UNSIGNED; 
  1319.    INPUT_ARGUEMENT_VECTOR          : in ADDRESS := ADDRESS'NULL_PARAMETER); 
  1320.  
  1321.   procedure GET_TERM_DATA --
  1322.   (STATUS                          : out COND_VALUE; 
  1323.    TERMTABLE_ADDRESS, REQUEST_CODE : in LONGWORD_SIGNED; 
  1324.    MAX_BUFFER_LENGTH               : in LONGWORD_SIGNED; 
  1325.    RETURN_LENGTH                   : out LONGWORD_SIGNED; 
  1326.    BUFFER_ADDRESS                  : out LONGWORD_UNSIGNED; 
  1327.    INPUT_ARGUEMENT_VECTOR          : in ADDRESS := ADDRESS'NULL_PARAMETER); 
  1328.  
  1329.   pragma INTERFACE(RTL, GET_TERM_DATA); 
  1330.  
  1331.   pragma IMPORT_PROCEDURE(GET_TERM_DATA, "SMG$GET_TERM_DATA", (LONGWORD_SIGNED, 
  1332.     LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_UNSIGNED, 
  1333.     ADDRESS)); 
  1334.  
  1335.   pragma IMPORT_PROCEDURE(GET_TERM_DATA, "SMG$GET_TERM_DATA", (COND_VALUE, 
  1336.     LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  1337.     LONGWORD_UNSIGNED, ADDRESS)); 
  1338.  
  1339.   --------------------------------------------------------------------------
  1340.   --------------------------------------------------------------------------
  1341.   --    moves the virtual cursor to the specified corner of a virtual display.
  1342.   --                                                               
  1343.  
  1344.   procedure HOME_CURSOR --
  1345.   (DISPLAY_ID : in LONGWORD_UNSIGNED; 
  1346.    POSITION   : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1347.  
  1348.   procedure HOME_CURSOR --
  1349.   (STATUS     : out COND_VALUE; 
  1350.    DISPLAY_ID : in LONGWORD_UNSIGNED; 
  1351.    POSITION   : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1352.  
  1353.   pragma INTERFACE(RTL, HOME_CURSOR); 
  1354.  
  1355.   pragma IMPORT_PROCEDURE(HOME_CURSOR, "SMG$HOME_CURSOR", (LONGWORD_UNSIGNED, 
  1356.     LONGWORD_UNSIGNED)); 
  1357.  
  1358.   pragma IMPORT_PROCEDURE(HOME_CURSOR, "SMG$HOME_CURSOR", (COND_VALUE, 
  1359.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1360.  
  1361.   --------------------------------------------------------------------------
  1362.   --------------------------------------------------------------------------
  1363.   --    initializes the TERMTABLE database for the terminal named, so that
  1364.   --    subsequent calls to SMT$GET_TERM_DATA cna extract information and
  1365.   --    command strings for that terminal.
  1366.   --
  1367.  
  1368.   procedure INIT_TERM_TABLE --
  1369.   (TERMINAL_NAME      : in CHAR_STRING; 
  1370.    TERM_ENTRY_ADDRESS : out LONGWORD_UNSIGNED); 
  1371.  
  1372.   procedure INIT_TERM_TABLE --
  1373.   (STATUS             : out COND_VALUE; 
  1374.    TERMINAL_NAME      : in CHAR_STRING; 
  1375.    TERM_ENTRY_ADDRESS : out LONGWORD_UNSIGNED); 
  1376.  
  1377.   pragma INTERFACE(RTL, INIT_TERM_TABLE); 
  1378.  
  1379.   pragma IMPORT_PROCEDURE(INIT_TERM_TABLE, "SMG$INIT_TERM_TABLE", (CHAR_STRING, 
  1380.     LONGWORD_UNSIGNED)); 
  1381.  
  1382.   pragma IMPORT_PROCEDURE(INIT_TERM_TABLE, "SMG$INIT_TERM_TABLE", (COND_VALUE, 
  1383.     CHAR_STRING, LONGWORD_UNSIGNED)); 
  1384.  
  1385.   --------------------------------------------------------------------------
  1386.   --------------------------------------------------------------------------
  1387.   --    initializes the TERMTABLE database for the terminal names, so that
  1388.   --    subsequent calls to SMG$GET_TERM_DATA can extract information and
  1389.   --    command strings for that terminal. 
  1390.   --                                      
  1391.  
  1392.   procedure INIT_TERM_TABLE_BY_TYPE --
  1393.   (TERMINAL_TYPE      : in BYTE_SIGNED; 
  1394.    TERM_ENTRY_ADDRESS : out LONGWORD_UNSIGNED; 
  1395.    TERMINAL_NAME      : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER
  1396.    -- VMS usage "device_name"; SMG_C_ASCII default and only possible value
  1397.    ); 
  1398.  
  1399.   procedure INIT_TERM_TABLE_BY_TYPE --
  1400.   (STATUS             : out COND_VALUE; 
  1401.    TERMINAL_TYPE      : in BYTE_SIGNED; 
  1402.    TERM_ENTRY_ADDRESS : out LONGWORD_UNSIGNED; 
  1403.    TERMINAL_NAME      : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER
  1404.    -- VMS usage "device_name"; SMG_C_ASCII default and only possible value
  1405.    ); 
  1406.  
  1407.   pragma INTERFACE(RTL, INIT_TERM_TABLE_BY_TYPE); 
  1408.  
  1409.   pragma IMPORT_PROCEDURE(INIT_TERM_TABLE_BY_TYPE, "SMG$INIT_TERM_TABLE_BY_TYPE"
  1410.     , (BYTE_SIGNED, LONGWORD_UNSIGNED, CHAR_STRING)); 
  1411.  
  1412.   pragma IMPORT_PROCEDURE(INIT_TERM_TABLE_BY_TYPE, "SMG$INIT_TERM_TABLE_BY_TYPE"
  1413.     , (COND_VALUE, BYTE_SIGNED, LONGWORD_UNSIGNED, CHAR_STRING)); 
  1414.  
  1415.   --------------------------------------------------------------------------
  1416.   --------------------------------------------------------------------------
  1417.   --    inserts the specified character string at the row and column positions
  1418.   --    specified.  Characters to the right of the insertion are shifted to
  1419.   --    the right.  Note that any characters which do not fie on the current
  1420.   --    line are discarded. The virtual cursor remains at the character
  1421.   --    position following the last character inserted.
  1422.   --
  1423.  
  1424.   procedure INSERT_CHARS --
  1425.   (DISPLAY_ID                          : in LONGWORD_UNSIGNED; 
  1426.    STRING                              : in CHAR_STRING; 
  1427.    ROW, COLUMN                         : in LONGWORD_SIGNED; 
  1428.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  1429.      NULL_PARAMETER; 
  1430.    CHAR_SET                            : in LONGWORD_UNSIGNED := 
  1431.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1432.  
  1433.   procedure INSERT_CHARS --
  1434.   (STATUS                              : out COND_VALUE; 
  1435.    DISPLAY_ID                          : in LONGWORD_UNSIGNED; 
  1436.    STRING                              : in CHAR_STRING; 
  1437.    ROW, COLUMN                         : in LONGWORD_SIGNED; 
  1438.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  1439.      NULL_PARAMETER; 
  1440.    CHAR_SET                            : in LONGWORD_UNSIGNED := 
  1441.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1442.  
  1443.   pragma INTERFACE(RTL, INSERT_CHARS); 
  1444.  
  1445.   pragma IMPORT_PROCEDURE(INSERT_CHARS, "SMG$INSERT_CHARS", (LONGWORD_UNSIGNED, 
  1446.     CHAR_STRING, LONGWORD_SIGNED, LONGWORD_SIGNED, MASK_LONGWORD, MASK_LONGWORD
  1447.     , LONGWORD_UNSIGNED)); 
  1448.  
  1449.   pragma IMPORT_PROCEDURE(INSERT_CHARS, "SMG$INSERT_CHARS", (COND_VALUE, 
  1450.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  1451.     MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1452.  
  1453.   --------------------------------------------------------------------------
  1454.   --------------------------------------------------------------------------
  1455.   --    inserts a line into a virtual display and scrolls the display.
  1456.   --
  1457.  
  1458.   procedure INSERT_LINE --
  1459.   (DISPLAY_ID                                     : in LONGWORD_UNSIGNED; 
  1460.    LINE_NUMBER                                    : in LONGWORD_SIGNED; 
  1461.    STRING                                         : in CHAR_STRING; 
  1462.    DIRECTION                                      : in LONGWORD_UNSIGNED := 
  1463.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  1464.    RENDITION_SET, RENDITION_COMPLEMENT, WRAP_FLAG : in MASK_LONGWORD := 
  1465.      MASK_LONGWORD'NULL_PARAMETER; 
  1466.    CHAR_SET                                       : in LONGWORD_UNSIGNED := 
  1467.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1468.  
  1469.   procedure INSERT_LINE --
  1470.   (STATUS                                         : out COND_VALUE; 
  1471.    DISPLAY_ID                                     : in LONGWORD_UNSIGNED; 
  1472.    LINE_NUMBER                                    : in LONGWORD_SIGNED; 
  1473.    STRING                                         : in CHAR_STRING; 
  1474.    DIRECTION                                      : in LONGWORD_UNSIGNED := 
  1475.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  1476.    RENDITION_SET, RENDITION_COMPLEMENT, WRAP_FLAG : in MASK_LONGWORD := 
  1477.      MASK_LONGWORD'NULL_PARAMETER; 
  1478.    CHAR_SET                                       : in LONGWORD_UNSIGNED := 
  1479.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1480.  
  1481.   pragma INTERFACE(RTL, INSERT_LINE); 
  1482.  
  1483.   pragma IMPORT_PROCEDURE(INSERT_LINE, "SMG$INSERT_LINE", (LONGWORD_UNSIGNED, 
  1484.     LONGWORD_SIGNED, CHAR_STRING, LONGWORD_UNSIGNED, MASK_LONGWORD, 
  1485.     MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1486.  
  1487.   pragma IMPORT_PROCEDURE(INSERT_LINE, "SMG$INSERT_LINE", (COND_VALUE, 
  1488.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, CHAR_STRING, LONGWORD_UNSIGNED, 
  1489.     MASK_LONGWORD, MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1490.  
  1491.   --------------------------------------------------------------------------
  1492.   --------------------------------------------------------------------------
  1493.   --    marks a display as invalid and causes the entire display to be 
  1494.   --    redrawn.
  1495.   --
  1496.  
  1497.   procedure INVALIDATE_DISPLAY --
  1498.   (DISPLAY_ID : in LONGWORD_UNSIGNED); 
  1499.  
  1500.   procedure INVALIDATE_DISPLAY --
  1501.   (STATUS     : out COND_VALUE; 
  1502.    DISPLAY_ID : in LONGWORD_UNSIGNED); 
  1503.  
  1504.   pragma INTERFACE(RTL, INVALIDATE_DISPLAY); 
  1505.  
  1506.   pragma IMPORT_PROCEDURE(INVALIDATE_DISPLAY, "SMG$INVALIDATE_DISPLAY", (
  1507.     LONGWORD_UNSIGNED)); 
  1508.  
  1509.   pragma IMPORT_PROCEDURE(INVALIDATE_DISPLAY, "SMG$INVALIDATE_DISPLAY", (
  1510.     COND_VALUE, LONGWORD_UNSIGNED)); 
  1511.  
  1512.   --------------------------------------------------------------------------
  1513.   --------------------------------------------------------------------------
  1514.   --    supplies a label virtual for a virtual display's border. 
  1515.   --
  1516.  
  1517.   procedure LABEL_BORDER --
  1518.   (DISPLAY_ID                          : in LONGWORD_UNSIGNED; 
  1519.    LABEL_TEXT                          : in CHAR_STRING; 
  1520.    POSITION                            : in LONGWORD_UNSIGNED := 
  1521.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  1522.    UNITS                               : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  1523.      NULL_PARAMETER; 
  1524.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  1525.      NULL_PARAMETER; 
  1526.    CHAR_SET                            : in LONGWORD_UNSIGNED := 
  1527.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1528.  
  1529.   procedure LABEL_BORDER --
  1530.   (STATUS                              : out COND_VALUE; 
  1531.    DISPLAY_ID                          : in LONGWORD_UNSIGNED; 
  1532.    LABEL_TEXT                          : in CHAR_STRING; 
  1533.    POSITION                            : in LONGWORD_UNSIGNED := 
  1534.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  1535.    UNITS                               : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  1536.      NULL_PARAMETER; 
  1537.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  1538.      NULL_PARAMETER; 
  1539.    CHAR_SET                            : in LONGWORD_UNSIGNED := 
  1540.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1541.  
  1542.   pragma INTERFACE(RTL, LABEL_BORDER); 
  1543.  
  1544.   pragma IMPORT_PROCEDURE(LABEL_BORDER, "SMG$LABEL_BORDER", (LONGWORD_UNSIGNED, 
  1545.     CHAR_STRING, LONGWORD_UNSIGNED, LONGWORD_SIGNED, MASK_LONGWORD, 
  1546.     MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1547.  
  1548.   pragma IMPORT_PROCEDURE(LABEL_BORDER, "SMG$LABEL_BORDER", (COND_VALUE, 
  1549.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_UNSIGNED, LONGWORD_SIGNED, 
  1550.     MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1551.  
  1552.   --------------------------------------------------------------------------
  1553.   --------------------------------------------------------------------------
  1554.   --    returns the definition(equivalence string) associated with a 
  1555.   --    specified key in a specified key in a speciried key table.
  1556.   --
  1557.  
  1558.   procedure LIST_KEY_DEFS --
  1559.   (KEY_TABLE_ID               : in LONGWORD_UNSIGNED; 
  1560.    CONTEXT                    : in CONTEXT_TYPE; 
  1561.    KEY_NAME, IF_STATE         : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  1562.    ATTRIBUTES                 : out LONGWORD_UNSIGNED; 
  1563.    EQUIV_STRING, STATE_STRING : out CHAR_STRING); 
  1564.  
  1565.   procedure LIST_KEY_DEFS --
  1566.   (STATUS                     : out COND_VALUE; 
  1567.    KEY_TABLE_ID               : in LONGWORD_UNSIGNED; 
  1568.    CONTEXT                    : in CONTEXT_TYPE; 
  1569.    KEY_NAME, IF_STATE         : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  1570.    ATTRIBUTES                 : out LONGWORD_UNSIGNED; 
  1571.    EQUIV_STRING, STATE_STRING : out CHAR_STRING); 
  1572.  
  1573.   procedure LIST_KEY_DEFS_1 --
  1574.   (KEY_TABLE_ID       : in LONGWORD_UNSIGNED; 
  1575.    CONTEXT            : in CONTEXT_TYPE; 
  1576.    KEY_NAME, IF_STATE : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER); 
  1577.  
  1578.   procedure LIST_KEY_DEFS_1 --
  1579.   (STATUS             : out COND_VALUE; 
  1580.    KEY_TABLE_ID       : in LONGWORD_UNSIGNED; 
  1581.    CONTEXT            : in CONTEXT_TYPE; 
  1582.    KEY_NAME, IF_STATE : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER); 
  1583.  
  1584.   pragma INTERFACE(RTL, LIST_KEY_DEFS); 
  1585.  
  1586.   pragma INTERFACE(RTL, LIST_KEY_DEFS_1); 
  1587.  
  1588.   pragma IMPORT_PROCEDURE(LIST_KEY_DEFS, "SMG$LIST_KEY_DEFS", (LONGWORD_UNSIGNED
  1589.     , CONTEXT_TYPE, CHAR_STRING, CHAR_STRING, LONGWORD_UNSIGNED, CHAR_STRING, 
  1590.     CHAR_STRING)); 
  1591.  
  1592.   pragma IMPORT_PROCEDURE(LIST_KEY_DEFS, "SMG$LIST_KEY_DEFS", (COND_VALUE, 
  1593.     LONGWORD_UNSIGNED, CONTEXT_TYPE, CHAR_STRING, CHAR_STRING, LONGWORD_UNSIGNED
  1594.     , CHAR_STRING, CHAR_STRING)); 
  1595.  
  1596.   pragma IMPORT_PROCEDURE(LIST_KEY_DEFS_1, "SMG$LIST_KEY_DEFS", (
  1597.     LONGWORD_UNSIGNED, CONTEXT_TYPE, CHAR_STRING, CHAR_STRING)); 
  1598.  
  1599.   pragma IMPORT_PROCEDURE(LIST_KEY_DEFS_1, "SMG$LIST_KEY_DEFS", (COND_VALUE, 
  1600.     LONGWORD_UNSIGNED, CONTEXT_TYPE, CHAR_STRING, CHAR_STRING)); 
  1601.  
  1602.   --------------------------------------------------------------------------
  1603.   --------------------------------------------------------------------------
  1604.   --    loads a file of key definitions(DEFINE/KEY commands) into a 
  1605.   --    specified key table.
  1606.   --
  1607.  
  1608.   procedure LOAD_KEY_DEFS --
  1609.   (KEY_TABLE_ID     : in LONGWORD_UNSIGNED; 
  1610.    FILESPEC         : in CHAR_STRING; 
  1611.    DEFAULT_FILESPEC : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  1612.    LOGNAM_FLAG      : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER); 
  1613.  
  1614.   procedure LOAD_KEY_DEFS --
  1615.   (STATUS           : out COND_VALUE; 
  1616.    KEY_TABLE_ID     : in LONGWORD_UNSIGNED; 
  1617.    FILESPEC         : in CHAR_STRING; 
  1618.    DEFAULT_FILESPEC : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  1619.    LOGNAM_FLAG      : in MASK_LONGWORD := MASK_LONGWORD'NULL_PARAMETER); 
  1620.  
  1621.   pragma INTERFACE(RTL, LOAD_KEY_DEFS); 
  1622.  
  1623.   pragma IMPORT_PROCEDURE(LOAD_KEY_DEFS, "SMG$LOAD_KEY_DEFS", (LONGWORD_UNSIGNED
  1624.     , CHAR_STRING, CHAR_STRING, MASK_LONGWORD)); 
  1625.  
  1626.   pragma IMPORT_PROCEDURE(LOAD_KEY_DEFS, "SMG$LOAD_KEY_DEFS", (COND_VALUE, 
  1627.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, MASK_LONGWORD)); 
  1628.  
  1629.   --------------------------------------------------------------------------
  1630.   --------------------------------------------------------------------------
  1631.   --    relocates a virtual display on a pasteboard and preserves the
  1632.   --    pasting order.
  1633.   --
  1634.  
  1635.   procedure MOVE_VIRTUAL_DISPLAY --
  1636.   (DISPLAY_ID, PASTEBOARD_ID         : in LONGWORD_UNSIGNED; 
  1637.    PASTEBOARD_ROW, PASTEBOARD_COLUMN : in LONGWORD_SIGNED; 
  1638.    TOP_DISPLAY_ID                    : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED
  1639.      'NULL_PARAMETER); 
  1640.  
  1641.   procedure MOVE_VIRTUAL_DISPLAY --
  1642.   (STATUS                            : out COND_VALUE; 
  1643.    DISPLAY_ID, PASTEBOARD_ID         : in LONGWORD_UNSIGNED; 
  1644.    PASTEBOARD_ROW, PASTEBOARD_COLUMN : in LONGWORD_SIGNED; 
  1645.    TOP_DISPLAY_ID                    : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED
  1646.      'NULL_PARAMETER); 
  1647.  
  1648.   pragma INTERFACE(RTL, MOVE_VIRTUAL_DISPLAY); 
  1649.  
  1650.   pragma IMPORT_PROCEDURE(MOVE_VIRTUAL_DISPLAY, "SMG$MOVE_VIRTUAL_DISPLAY", (
  1651.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  1652.     LONGWORD_UNSIGNED)); 
  1653.  
  1654.   pragma IMPORT_PROCEDURE(MOVE_VIRTUAL_DISPLAY, "SMG$MOVE_VIRTUAL_DISPLAY", (
  1655.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED, 
  1656.     LONGWORD_SIGNED, LONGWORD_UNSIGNED)); 
  1657.  
  1658.   --------------------------------------------------------------------------
  1659.   --------------------------------------------------------------------------
  1660.   --    places a display on a pasteboard and makes the display visible.
  1661.   --    If, however, the optional argument top-display-id is specified,
  1662.   --    SMG$PASTE_VIRTUAL_DISPLAY pastes the virtual display being pasted
  1663.   --    under the virtual display specified by top-display-id.  In this
  1664.   --    case, the virtual display specified by top-display-id must already
  1665.   --    be pasted.
  1666.   --
  1667.  
  1668.   procedure PASTE_VIRTUAL_DISPLAY --
  1669.   (DISPLAY_ID, PASTEBOARD_ID         : in LONGWORD_UNSIGNED; 
  1670.    PASTEBOARD_ROW, PASTEBOARD_COLUMN : in LONGWORD_SIGNED; 
  1671.    TOP_DISPLAY_ID                    : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED
  1672.      'NULL_PARAMETER); 
  1673.  
  1674.   procedure PASTE_VIRTUAL_DISPLAY --
  1675.   (STATUS                            : out COND_VALUE; 
  1676.    DISPLAY_ID, PASTEBOARD_ID         : in LONGWORD_UNSIGNED; 
  1677.    PASTEBOARD_ROW, PASTEBOARD_COLUMN : in LONGWORD_SIGNED; 
  1678.    TOP_DISPLAY_ID                    : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED
  1679.      'NULL_PARAMETER); 
  1680.  
  1681.   pragma INTERFACE(RTL, PASTE_VIRTUAL_DISPLAY); 
  1682.  
  1683.   pragma IMPORT_PROCEDURE(PASTE_VIRTUAL_DISPLAY, "SMG$PASTE_VIRTUAL_DISPLAY", (
  1684.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  1685.     LONGWORD_UNSIGNED)); 
  1686.  
  1687.   pragma IMPORT_PROCEDURE(PASTE_VIRTUAL_DISPLAY, "SMG$PASTE_VIRTUAL_DISPLAY", (
  1688.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED, 
  1689.     LONGWORD_SIGNED, LONGWORD_UNSIGNED)); 
  1690.  
  1691.   --------------------------------------------------------------------------
  1692.   --------------------------------------------------------------------------
  1693.   --    deletes a specified virtual display and all displays that were 
  1694.   --    pasted on the specified pasteboard after the specified virtual 
  1695.   --    display.
  1696.   --
  1697.  
  1698.   procedure POP_VIRTUAL_DISPLAY --
  1699.   (DISPLAY_ID, PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  1700.  
  1701.   procedure POP_VIRTUAL_DISPLAY --
  1702.   (STATUS                    : out COND_VALUE; 
  1703.    DISPLAY_ID, PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  1704.  
  1705.   pragma INTERFACE(RTL, POP_VIRTUAL_DISPLAY); 
  1706.  
  1707.   pragma IMPORT_PROCEDURE(POP_VIRTUAL_DISPLAY, "SMG$POP_VIRTUAL_DISPLAY", (
  1708.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1709.  
  1710.   pragma IMPORT_PROCEDURE(POP_VIRTUAL_DISPLAY, "SMG$POP_VIRTUAL_DISPLAY", (
  1711.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1712.  
  1713.   --------------------------------------------------------------------------
  1714.   --------------------------------------------------------------------------
  1715.   --    overwrites characters in a virtual display with the text you 
  1716.   --    specify.
  1717.   --
  1718.  
  1719.   procedure PUT_CHARS --
  1720.   (DISPLAY_ID                                      : in LONGWORD_UNSIGNED; 
  1721.    TEXT                                            : in CHAR_STRING; 
  1722.    LINE_NUMBER, COLUMN_NUMBER                      : in LONGWORD_SIGNED := 
  1723.      LONGWORD_SIGNED'NULL_PARAMETER; 
  1724.    ERASE_FLAG, RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := 
  1725.      MASK_LONGWORD'NULL_PARAMETER; 
  1726.    CHAR_SET                                        : in LONGWORD_UNSIGNED := 
  1727.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1728.  
  1729.   procedure PUT_CHARS --
  1730.   (STATUS                                          : out COND_VALUE; 
  1731.    DISPLAY_ID                                      : in LONGWORD_UNSIGNED; 
  1732.    TEXT                                            : in CHAR_STRING; 
  1733.    LINE_NUMBER, COLUMN_NUMBER                      : in LONGWORD_SIGNED := 
  1734.      LONGWORD_SIGNED'NULL_PARAMETER; 
  1735.    ERASE_FLAG, RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := 
  1736.      MASK_LONGWORD'NULL_PARAMETER; 
  1737.    CHAR_SET                                        : in LONGWORD_UNSIGNED := 
  1738.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1739.  
  1740.   pragma INTERFACE(RTL, PUT_CHARS); 
  1741.  
  1742.   pragma IMPORT_PROCEDURE(PUT_CHARS, "SMG$PUT_CHARS", (LONGWORD_UNSIGNED, 
  1743.     CHAR_STRING, LONGWORD_SIGNED, LONGWORD_SIGNED, MASK_LONGWORD, MASK_LONGWORD
  1744.     , MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1745.  
  1746.   pragma IMPORT_PROCEDURE(PUT_CHARS, "SMG$PUT_CHARS", (COND_VALUE, 
  1747.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  1748.     MASK_LONGWORD, MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1749.  
  1750.   --------------------------------------------------------------------------
  1751.   --------------------------------------------------------------------------
  1752.   --    write double-height, double-width characters to a virtual display.
  1753.   --
  1754.  
  1755.   procedure PUT_CHARS_HIGHWIDE --
  1756.   (DISPLAY_ID                          : in LONGWORD_UNSIGNED; 
  1757.    TEXT                                : in CHAR_STRING; 
  1758.    LINE_NUMBER, COLUMN_NUMBER          : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  1759.      NULL_PARAMETER; 
  1760.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  1761.      NULL_PARAMETER; 
  1762.    CHAR_SET                            : in LONGWORD_UNSIGNED := 
  1763.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1764.  
  1765.   procedure PUT_CHARS_HIGHWIDE --
  1766.   (STATUS                              : out COND_VALUE; 
  1767.    DISPLAY_ID                          : in LONGWORD_UNSIGNED; 
  1768.    TEXT                                : in CHAR_STRING; 
  1769.    LINE_NUMBER, COLUMN_NUMBER          : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  1770.      NULL_PARAMETER; 
  1771.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  1772.      NULL_PARAMETER; 
  1773.    CHAR_SET                            : in LONGWORD_UNSIGNED := 
  1774.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1775.  
  1776.   pragma INTERFACE(RTL, PUT_CHARS_HIGHWIDE); 
  1777.  
  1778.   pragma IMPORT_PROCEDURE(PUT_CHARS_HIGHWIDE, "SMG$PUT_CHARS_HIGHWIDE", (
  1779.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  1780.     MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1781.  
  1782.   pragma IMPORT_PROCEDURE(PUT_CHARS_HIGHWIDE, "SMG$PUT_CHARS_HIGHWIDE", (
  1783.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, LONGWORD_SIGNED
  1784.     , MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1785.  
  1786.   --------------------------------------------------------------------------
  1787.   --------------------------------------------------------------------------
  1788.   --    writes double-width characters to a virtual display.
  1789.   --
  1790.  
  1791.   procedure PUT_CHARS_WIDE --
  1792.   (DISPLAY_ID                          : in LONGWORD_UNSIGNED; 
  1793.    TEXT                                : in CHAR_STRING; 
  1794.    LINE_NUMBER, COLUMN_NUMBER          : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  1795.      NULL_PARAMETER; 
  1796.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  1797.      NULL_PARAMETER; 
  1798.    CHAR_SET                            : in LONGWORD_UNSIGNED := 
  1799.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1800.  
  1801.   procedure PUT_CHARS_WIDE --
  1802.   (STATUS                              : out COND_VALUE; 
  1803.    DISPLAY_ID                          : in LONGWORD_UNSIGNED; 
  1804.    TEXT                                : in CHAR_STRING; 
  1805.    LINE_NUMBER, COLUMN_NUMBER          : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  1806.      NULL_PARAMETER; 
  1807.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  1808.      NULL_PARAMETER; 
  1809.    CHAR_SET                            : in LONGWORD_UNSIGNED := 
  1810.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1811.  
  1812.   pragma INTERFACE(RTL, PUT_CHARS_WIDE); 
  1813.  
  1814.   pragma IMPORT_PROCEDURE(PUT_CHARS_WIDE, "SMG$PUT_CHARS_WIDE", (
  1815.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  1816.     MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1817.  
  1818.   pragma IMPORT_PROCEDURE(PUT_CHARS_WIDE, "SMG$PUT_CHARS_WIDE", (COND_VALUE, 
  1819.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  1820.     MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1821.  
  1822.   --------------------------------------------------------------------------
  1823.   --------------------------------------------------------------------------
  1824.   --    writes a line of text to a virtual display.
  1825.   --
  1826.  
  1827.   procedure PUT_LINE --
  1828.   (DISPLAY_ID                                     : in LONGWORD_UNSIGNED; 
  1829.    TEXT                                           : in CHAR_STRING; 
  1830.    LINE_ADVANCE                                   : in LONGWORD_SIGNED := 
  1831.      LONGWORD_SIGNED'NULL_PARAMETER; 
  1832.    RENDITION_SET, RENDITION_COMPLEMENT, WRAP_FLAG : in MASK_LONGWORD := 
  1833.      MASK_LONGWORD'NULL_PARAMETER; 
  1834.    CHAR_SET, DIRECTION                            : in LONGWORD_UNSIGNED := 
  1835.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1836.  
  1837.   procedure PUT_LINE --
  1838.   (STATUS                                         : out COND_VALUE; 
  1839.    DISPLAY_ID                                     : in LONGWORD_UNSIGNED; 
  1840.    TEXT                                           : in CHAR_STRING; 
  1841.    LINE_ADVANCE                                   : in LONGWORD_SIGNED := 
  1842.      LONGWORD_SIGNED'NULL_PARAMETER; 
  1843.    RENDITION_SET, RENDITION_COMPLEMENT, WRAP_FLAG : in MASK_LONGWORD := 
  1844.      MASK_LONGWORD'NULL_PARAMETER; 
  1845.    CHAR_SET, DIRECTION                            : in LONGWORD_UNSIGNED := 
  1846.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1847.  
  1848.   pragma INTERFACE(RTL, PUT_LINE); 
  1849.  
  1850.   pragma IMPORT_PROCEDURE(PUT_LINE, "SMG$PUT_LINE", (LONGWORD_UNSIGNED, 
  1851.     CHAR_STRING, LONGWORD_SIGNED, MASK_LONGWORD, MASK_LONGWORD, MASK_LONGWORD, 
  1852.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1853.  
  1854.   pragma IMPORT_PROCEDURE(PUT_LINE, "SMG$PUT_LINE", (COND_VALUE, 
  1855.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, MASK_LONGWORD, 
  1856.     MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  1857.  
  1858.   --------------------------------------------------------------------------
  1859.   --------------------------------------------------------------------------
  1860.   --    writes lines with double high and double wide characters.
  1861.   --
  1862.  
  1863.   procedure PUT_LINE_HIGHWIDE --
  1864.   (DISPLAY_ID                                     : in LONGWORD_UNSIGNED; 
  1865.    TEXT                                           : in CHAR_STRING; 
  1866.    LINE_ADV                                       : in LONGWORD_SIGNED := 
  1867.      LONGWORD_SIGNED'NULL_PARAMETER; 
  1868.    RENDITION_SET, RENDITION_COMPLEMENT, WRAP_FLAG : in LONGWORD_UNSIGNED := 
  1869.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  1870.    CHAR_SET                                       : in LONGWORD_SIGNED := 
  1871.      LONGWORD_SIGNED'NULL_PARAMETER); 
  1872.  
  1873.   procedure PUT_LINE_HIGHWIDE --
  1874.   (STATUS                                         : out COND_VALUE; 
  1875.    DISPLAY_ID                                     : in LONGWORD_UNSIGNED; 
  1876.    TEXT                                           : in CHAR_STRING; 
  1877.    LINE_ADV                                       : in LONGWORD_SIGNED := 
  1878.      LONGWORD_SIGNED'NULL_PARAMETER; 
  1879.    RENDITION_SET, RENDITION_COMPLEMENT, WRAP_FLAG : in LONGWORD_UNSIGNED := 
  1880.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  1881.    CHAR_SET                                       : in LONGWORD_SIGNED := 
  1882.      LONGWORD_SIGNED'NULL_PARAMETER); 
  1883.  
  1884.   pragma INTERFACE(RTL, PUT_LINE_HIGHWIDE); 
  1885.  
  1886.   pragma IMPORT_PROCEDURE(PUT_LINE_HIGHWIDE, "SMG$PUT_LINE_HIGHWIDE", (
  1887.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, LONGWORD_UNSIGNED, 
  1888.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED)); 
  1889.  
  1890.   pragma IMPORT_PROCEDURE(PUT_LINE_HIGHWIDE, "SMG$PUT_LINE_HIGHWIDE", (
  1891.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, 
  1892.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED)); 
  1893.  
  1894.   --------------------------------------------------------------------------
  1895.   --------------------------------------------------------------------------
  1896.   --    writes a line of double-width text to a virtual display.
  1897.   --
  1898.  
  1899.   procedure PUT_LINE_WIDE --
  1900.   (DISPLAY_ID                                     : in LONGWORD_UNSIGNED; 
  1901.    TEXT                                           : in CHAR_STRING; 
  1902.    LINE_ADVANCE                                   : in LONGWORD_SIGNED := 
  1903.      LONGWORD_SIGNED'NULL_PARAMETER; 
  1904.    RENDITION_SET, RENDITION_COMPLEMENT, WRAP_FLAG : in MASK_LONGWORD := 
  1905.      MASK_LONGWORD'NULL_PARAMETER; 
  1906.    CHAR_SET                                       : in LONGWORD_UNSIGNED := 
  1907.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1908.  
  1909.   procedure PUT_LINE_WIDE --
  1910.   (STATUS                                         : out COND_VALUE; 
  1911.    DISPLAY_ID                                     : in LONGWORD_UNSIGNED; 
  1912.    TEXT                                           : in CHAR_STRING; 
  1913.    LINE_ADVANCE                                   : in LONGWORD_SIGNED := 
  1914.      LONGWORD_SIGNED'NULL_PARAMETER; 
  1915.    RENDITION_SET, RENDITION_COMPLEMENT, WRAP_FLAG : in MASK_LONGWORD := 
  1916.      MASK_LONGWORD'NULL_PARAMETER; 
  1917.    CHAR_SET                                       : in LONGWORD_UNSIGNED := 
  1918.      LONGWORD_UNSIGNED'NULL_PARAMETER); 
  1919.  
  1920.   pragma INTERFACE(RTL, PUT_LINE_WIDE); 
  1921.  
  1922.   pragma IMPORT_PROCEDURE(PUT_LINE_WIDE, "SMG$PUT_LINE_WIDE", (LONGWORD_UNSIGNED
  1923.     , CHAR_STRING, LONGWORD_SIGNED, MASK_LONGWORD, MASK_LONGWORD, MASK_LONGWORD
  1924.     , LONGWORD_UNSIGNED)); 
  1925.  
  1926.   pragma IMPORT_PROCEDURE(PUT_LINE_WIDE, "SMG$PUT_LINE_WIDE", (COND_VALUE, 
  1927.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, MASK_LONGWORD, 
  1928.     MASK_LONGWORD, MASK_LONGWORD, LONGWORD_UNSIGNED)); 
  1929.  
  1930.   --------------------------------------------------------------------------
  1931.   --------------------------------------------------------------------------
  1932.   --    routine accesses the contents of a pasteboard. The caller specifies 
  1933.   --    an action routine that will be called once for each line in the 
  1934.   --    pasteboard.  The action routine will be passed a descriptor for
  1935.   --    for that line followed by a user-specified argument.
  1936.   --
  1937.  
  1938.   procedure PUT_PASTEBOARD --
  1939.   (PASTEBOARD_ID, P_RTN : in LONGWORD_UNSIGNED; 
  1940.    P_PRM                : in USER_ARG; 
  1941.    P_FF_FLAG            : in MASK_LONGWORD); 
  1942.  
  1943.   procedure PUT_PASTEBOARD --
  1944.   (STATUS               : out COND_VALUE; 
  1945.    PASTEBOARD_ID, P_RTN : in LONGWORD_UNSIGNED; 
  1946.    P_PRM                : in USER_ARG; 
  1947.    P_FF_FLAG            : in MASK_LONGWORD); 
  1948.  
  1949.   pragma INTERFACE(RTL, PUT_PASTEBOARD); 
  1950.  
  1951.   pragma IMPORT_PROCEDURE(PUT_PASTEBOARD, "SMG$PUT_PASTEBOARD", (
  1952.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, USER_ARG, MASK_LONGWORD)); 
  1953.  
  1954.   pragma IMPORT_PROCEDURE(PUT_PASTEBOARD, "SMG$PUT_PASTEBOARD", (COND_VALUE, 
  1955.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, USER_ARG, MASK_LONGWORD)); 
  1956.  
  1957.   --------------------------------------------------------------------------
  1958.   --------------------------------------------------------------------------
  1959.   --    reads a line of input composed of normal keystrokes and 
  1960.   --    equivalence strings.
  1961.   --
  1962.  
  1963.   procedure READ_COMPOSED_LINE --
  1964.   (KEYBOARD_ID, KEY_TABLE_ID           : in LONGWORD_UNSIGNED; 
  1965.    RECEIVED_TEXT                       : out CHAR_STRING; 
  1966.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  1967.      NULL_PARAMETER; 
  1968.    RECEIVED_STRING_LENGTH              : out WORD_UNSIGNED; 
  1969.    DISPLAY_ID, FUNCTION_KEYS_FLAG      : in LONGWORD_UNSIGNED := 
  1970.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  1971.    INI_STRING                          : in CHAR_STRING := CHAR_STRING'
  1972.      NULL_PARAMETER; 
  1973.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  1974.      NULL_PARAMETER; 
  1975.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  1976.      NULL_PARAMETER; 
  1977.    TERMINATOR_CODE                     : out WORD_UNSIGNED); 
  1978.  
  1979.   procedure READ_COMPOSED_LINE --
  1980.   (STATUS                              : out COND_VALUE; 
  1981.    KEYBOARD_ID, KEY_TABLE_ID           : in LONGWORD_UNSIGNED; 
  1982.    RECEIVED_TEXT                       : out CHAR_STRING; 
  1983.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  1984.      NULL_PARAMETER; 
  1985.    RECEIVED_STRING_LENGTH              : out WORD_UNSIGNED; 
  1986.    DISPLAY_ID, FUNCTION_KEYS_FLAG      : in LONGWORD_UNSIGNED := 
  1987.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  1988.    INI_STRING                          : in CHAR_STRING := CHAR_STRING'
  1989.      NULL_PARAMETER; 
  1990.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  1991.      NULL_PARAMETER; 
  1992.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  1993.      NULL_PARAMETER; 
  1994.    TERMINATOR_CODE                     : out WORD_UNSIGNED); 
  1995.  
  1996.   procedure READ_COMPOSED_LINE_1 --
  1997.   (KEYBOARD_ID, KEY_TABLE_ID           : in LONGWORD_UNSIGNED; 
  1998.    RECEIVED_TEXT                       : out CHAR_STRING; 
  1999.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  2000.      NULL_PARAMETER; 
  2001.    DISPLAY_ID, FUNCTION_KEYS_FLAG      : in LONGWORD_UNSIGNED := 
  2002.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2003.    INI_STRING                          : in CHAR_STRING := CHAR_STRING'
  2004.      NULL_PARAMETER; 
  2005.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2006.      NULL_PARAMETER; 
  2007.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  2008.      NULL_PARAMETER); 
  2009.  
  2010.   procedure READ_COMPOSED_LINE_1 --
  2011.   (STATUS                              : out COND_VALUE; 
  2012.    KEYBOARD_ID, KEY_TABLE_ID           : in LONGWORD_UNSIGNED; 
  2013.    RECEIVED_TEXT                       : out CHAR_STRING; 
  2014.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  2015.      NULL_PARAMETER; 
  2016.    DISPLAY_ID, FUNCTION_KEYS_FLAG      : in LONGWORD_UNSIGNED := 
  2017.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2018.    INI_STRING                          : in CHAR_STRING := CHAR_STRING'
  2019.      NULL_PARAMETER; 
  2020.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2021.      NULL_PARAMETER; 
  2022.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  2023.      NULL_PARAMETER); 
  2024.  
  2025.   pragma INTERFACE(RTL, READ_COMPOSED_LINE); 
  2026.  
  2027.   pragma INTERFACE(RTL, READ_COMPOSED_LINE_1); 
  2028.  
  2029.   pragma IMPORT_PROCEDURE(READ_COMPOSED_LINE, "SMG$READ_COMPOSED_LINE", (
  2030.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, 
  2031.     WORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, 
  2032.     LONGWORD_SIGNED, MASK_LONGWORD, MASK_LONGWORD, WORD_UNSIGNED)); 
  2033.  
  2034.   pragma IMPORT_PROCEDURE(READ_COMPOSED_LINE, "SMG$READ_COMPOSED_LINE", (
  2035.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, 
  2036.     WORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, 
  2037.     LONGWORD_SIGNED, MASK_LONGWORD, MASK_LONGWORD, WORD_UNSIGNED)); 
  2038.  
  2039.   pragma IMPORT_PROCEDURE(READ_COMPOSED_LINE_1, "SMG$READ_COMPOSED_LINE", (
  2040.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, 
  2041.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, 
  2042.     MASK_LONGWORD, MASK_LONGWORD)); 
  2043.  
  2044.   pragma IMPORT_PROCEDURE(READ_COMPOSED_LINE_1, "SMG$READ_COMPOSED_LINE", (
  2045.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, 
  2046.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, 
  2047.     MASK_LONGWORD, MASK_LONGWORD)); 
  2048.  
  2049.   --------------------------------------------------------------------------
  2050.   --------------------------------------------------------------------------
  2051.   --    reads a line of text from a virtual display.
  2052.   --
  2053.  
  2054.   procedure READ_FROM_DISPLAY --
  2055.   (DISPLAY_ID        : in LONGWORD_UNSIGNED; 
  2056.    RETURNED_STRING   : out CHAR_STRING; 
  2057.    TERMINATOR_STRING : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  2058.    ROW               : in LONGWORD_SIGNED := LONGWORD_SIGNED'NULL_PARAMETER); 
  2059.  
  2060.   procedure READ_FROM_DISPLAY --
  2061.   (STATUS            : out COND_VALUE; 
  2062.    DISPLAY_ID        : in LONGWORD_UNSIGNED; 
  2063.    RETURNED_STRING   : out CHAR_STRING; 
  2064.    TERMINATOR_STRING : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  2065.    ROW               : in LONGWORD_SIGNED := LONGWORD_SIGNED'NULL_PARAMETER); 
  2066.  
  2067.   pragma INTERFACE(RTL, READ_FROM_DISPLAY); 
  2068.  
  2069.   pragma IMPORT_PROCEDURE(READ_FROM_DISPLAY, "SMG$READ_FROM_DISPLAY", (
  2070.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, LONGWORD_SIGNED)); 
  2071.  
  2072.   pragma IMPORT_PROCEDURE(READ_FROM_DISPLAY, "SMG$READ_FROM_DISPLAY", (
  2073.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, LONGWORD_SIGNED)); 
  2074.  
  2075.   --------------------------------------------------------------------------
  2076.   --------------------------------------------------------------------------
  2077.   --    reads a keystroke and returns that keystroke's terminator code.
  2078.   --
  2079.  
  2080.   procedure READ_KEYSTROKE --
  2081.   (KEYBOARD_ID                         : in LONGWORD_UNSIGNED; 
  2082.    TERMINATOR_CODE                     : out WORD_UNSIGNED; 
  2083.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  2084.      NULL_PARAMETER; 
  2085.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2086.      NULL_PARAMETER; 
  2087.    DISPLAY_ID                          : in LONGWORD_UNSIGNED := 
  2088.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2089.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  2090.      NULL_PARAMETER); 
  2091.  
  2092.   procedure READ_KEYSTROKE --
  2093.   (STATUS                              : out COND_VALUE; 
  2094.    KEYBOARD_ID                         : in LONGWORD_UNSIGNED; 
  2095.    TERMINATOR_CODE                     : out WORD_UNSIGNED; 
  2096.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  2097.      NULL_PARAMETER; 
  2098.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2099.      NULL_PARAMETER; 
  2100.    DISPLAY_ID                          : in LONGWORD_UNSIGNED := 
  2101.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2102.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  2103.      NULL_PARAMETER); 
  2104.  
  2105.   pragma INTERFACE(RTL, READ_KEYSTROKE); 
  2106.  
  2107.   pragma IMPORT_PROCEDURE(READ_KEYSTROKE, "SMG$READ_KEYSTROKE", (
  2108.     LONGWORD_UNSIGNED, WORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, 
  2109.     LONGWORD_UNSIGNED, MASK_LONGWORD, MASK_LONGWORD)); 
  2110.  
  2111.   pragma IMPORT_PROCEDURE(READ_KEYSTROKE, "SMG$READ_KEYSTROKE", (COND_VALUE, 
  2112.     LONGWORD_UNSIGNED, WORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, 
  2113.     LONGWORD_UNSIGNED, MASK_LONGWORD, MASK_LONGWORD)); 
  2114.  
  2115.   --------------------------------------------------------------------------
  2116.   --------------------------------------------------------------------------
  2117.   --    reads a string form a virtual keyboard.
  2118.   --
  2119.  
  2120.   procedure READ_STRING --
  2121.   (KEYBOARD_ID                             : in LONGWORD_UNSIGNED; 
  2122.    RECEIVED_TEXT                           : out CHAR_STRING; 
  2123.    PROMPT_STRING                           : in CHAR_STRING := CHAR_STRING'
  2124.      NULL_PARAMETER; 
  2125.    MAX_LENGTH                              : in LONGWORD_SIGNED := 
  2126.      LONGWORD_SIGNED'NULL_PARAMETER; 
  2127.    MODIFIERS                               : in MASK_LONGWORD := MASK_LONGWORD'
  2128.      NULL_PARAMETER; 
  2129.    TIMEOUT                                 : in LONGWORD_SIGNED := 
  2130.      LONGWORD_SIGNED'NULL_PARAMETER; 
  2131.    TERMINATOR_SET                          : in CHAR_STRING := CHAR_STRING'
  2132.      NULL_PARAMETER; 
  2133.    RECEIVED_STRING_LENGTH, TERMINATOR_CODE : out WORD_UNSIGNED; 
  2134.    DISPLAY_ID                              : in LONGWORD_UNSIGNED := 
  2135.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2136.    INI_STRING                              : in CHAR_STRING := CHAR_STRING'
  2137.      NULL_PARAMETER; 
  2138.    RENDITION_SET, RENDITION_COMPLEMENT     : in MASK_LONGWORD := MASK_LONGWORD'
  2139.      NULL_PARAMETER); 
  2140.  
  2141.   procedure READ_STRING --
  2142.   (STATUS                                  : out COND_VALUE; 
  2143.    KEYBOARD_ID                             : in LONGWORD_UNSIGNED; 
  2144.    RECEIVED_TEXT                           : out CHAR_STRING; 
  2145.    PROMPT_STRING                           : in CHAR_STRING := CHAR_STRING'
  2146.      NULL_PARAMETER; 
  2147.    MAX_LENGTH                              : in LONGWORD_SIGNED := 
  2148.      LONGWORD_SIGNED'NULL_PARAMETER; 
  2149.    MODIFIERS                               : in MASK_LONGWORD := MASK_LONGWORD'
  2150.      NULL_PARAMETER; 
  2151.    TIMEOUT                                 : in LONGWORD_SIGNED := 
  2152.      LONGWORD_SIGNED'NULL_PARAMETER; 
  2153.    TERMINATOR_SET                          : in CHAR_STRING := CHAR_STRING'
  2154.      NULL_PARAMETER; 
  2155.    RECEIVED_STRING_LENGTH, TERMINATOR_CODE : out WORD_UNSIGNED; 
  2156.    DISPLAY_ID                              : in LONGWORD_UNSIGNED := 
  2157.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2158.    INI_STRING                              : in CHAR_STRING := CHAR_STRING'
  2159.      NULL_PARAMETER; 
  2160.    RENDITION_SET, RENDITION_COMPLEMENT     : in MASK_LONGWORD := MASK_LONGWORD'
  2161.      NULL_PARAMETER); 
  2162.  
  2163.   procedure READ_STRING_1 --
  2164.   (KEYBOARD_ID                         : in LONGWORD_UNSIGNED; 
  2165.    RECEIVED_TEXT                       : out CHAR_STRING; 
  2166.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  2167.      NULL_PARAMETER; 
  2168.    MAX_LENGTH                          : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2169.      NULL_PARAMETER; 
  2170.    MODIFIERS                           : in MASK_LONGWORD := MASK_LONGWORD'
  2171.      NULL_PARAMETER; 
  2172.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2173.      NULL_PARAMETER; 
  2174.    TERMINATOR_SET                      : in CHAR_STRING := CHAR_STRING'
  2175.      NULL_PARAMETER; 
  2176.    DISPLAY_ID                          : in LONGWORD_UNSIGNED := 
  2177.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2178.    INI_STRING                          : in CHAR_STRING := CHAR_STRING'
  2179.      NULL_PARAMETER; 
  2180.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  2181.      NULL_PARAMETER); 
  2182.  
  2183.   procedure READ_STRING_1 --
  2184.   (STATUS                              : out COND_VALUE; 
  2185.    KEYBOARD_ID                         : in LONGWORD_UNSIGNED; 
  2186.    RECEIVED_TEXT                       : out CHAR_STRING; 
  2187.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  2188.      NULL_PARAMETER; 
  2189.    MAX_LENGTH                          : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2190.      NULL_PARAMETER; 
  2191.    MODIFIERS                           : in MASK_LONGWORD := MASK_LONGWORD'
  2192.      NULL_PARAMETER; 
  2193.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2194.      NULL_PARAMETER; 
  2195.    TERMINATOR_SET                      : in CHAR_STRING := CHAR_STRING'
  2196.      NULL_PARAMETER; 
  2197.    DISPLAY_ID                          : in LONGWORD_UNSIGNED := 
  2198.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2199.    INI_STRING                          : in CHAR_STRING := CHAR_STRING'
  2200.      NULL_PARAMETER; 
  2201.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  2202.      NULL_PARAMETER); 
  2203.  
  2204.   pragma INTERFACE(RTL, READ_STRING); 
  2205.  
  2206.   pragma INTERFACE(RTL, READ_STRING_1); 
  2207.  
  2208.   pragma IMPORT_PROCEDURE(READ_STRING, "SMG$READ_STRING", (LONGWORD_UNSIGNED, 
  2209.     CHAR_STRING, CHAR_STRING, LONGWORD_SIGNED, MASK_LONGWORD, LONGWORD_SIGNED, 
  2210.     CHAR_STRING, WORD_UNSIGNED, WORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, 
  2211.     MASK_LONGWORD, MASK_LONGWORD)); 
  2212.  
  2213.   pragma IMPORT_PROCEDURE(READ_STRING, "SMG$READ_STRING", (COND_VALUE, 
  2214.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, LONGWORD_SIGNED, MASK_LONGWORD
  2215.     , LONGWORD_SIGNED, CHAR_STRING, WORD_UNSIGNED, WORD_UNSIGNED, 
  2216.     LONGWORD_UNSIGNED, CHAR_STRING, MASK_LONGWORD, MASK_LONGWORD)); 
  2217.  
  2218.   pragma IMPORT_PROCEDURE(READ_STRING_1, "SMG$READ_STRING", (LONGWORD_UNSIGNED, 
  2219.     CHAR_STRING, CHAR_STRING, LONGWORD_SIGNED, MASK_LONGWORD, LONGWORD_SIGNED, 
  2220.     CHAR_STRING, LONGWORD_UNSIGNED, CHAR_STRING, MASK_LONGWORD, MASK_LONGWORD))
  2221.     ; 
  2222.  
  2223.   pragma IMPORT_PROCEDURE(READ_STRING_1, "SMG$READ_STRING", (COND_VALUE, 
  2224.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, LONGWORD_SIGNED, MASK_LONGWORD
  2225.     , LONGWORD_SIGNED, CHAR_STRING, LONGWORD_UNSIGNED, CHAR_STRING, 
  2226.     MASK_LONGWORD, MASK_LONGWORD)); 
  2227.  
  2228.   --------------------------------------------------------------------------
  2229.   --------------------------------------------------------------------------
  2230.   --    reads a sequence of characters and verifies the sequence.
  2231.   --
  2232.  
  2233.   procedure READ_VERIFY --
  2234.   (KEYBOARD_ID                         : in LONGWORD_UNSIGNED; 
  2235.    OUT_STRING, IN_STRING               : out CHAR_STRING; 
  2236.    PIC_STRING, FILL_CHAR, CLEAR_CHAR   : in CHAR_STRING; 
  2237.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  2238.      NULL_PARAMETER; 
  2239.    MODIFIERS                           : in MASK_LONGWORD := MASK_LONGWORD'
  2240.      NULL_PARAMETER; 
  2241.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2242.      NULL_PARAMETER; 
  2243.    TERMINATOR_SET                      : in CHAR_STRING := CHAR_STRING'
  2244.      NULL_PARAMETER; 
  2245.    INI_OFFSET                          : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2246.      NULL_PARAMETER; 
  2247.    TERMINATOR_CODE                     : out WORD_UNSIGNED; 
  2248.    DISPLAY_ID                          : in LONGWORD_UNSIGNED := 
  2249.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2250.    ALT_ECHO_STRING                     : in CHAR_STRING := CHAR_STRING'
  2251.      NULL_PARAMETER; 
  2252.    ALT_DISPLAY_ID                      : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2253.      NULL_PARAMETER; 
  2254.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  2255.      NULL_PARAMETER); 
  2256.  
  2257.   procedure READ_VERIFY --
  2258.   (STATUS                              : out COND_VALUE; 
  2259.    KEYBOARD_ID                         : in LONGWORD_UNSIGNED; 
  2260.    OUT_STRING, IN_STRING               : out CHAR_STRING; 
  2261.    PIC_STRING, FILL_CHAR, CLEAR_CHAR   : in CHAR_STRING; 
  2262.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  2263.      NULL_PARAMETER; 
  2264.    MODIFIERS                           : in MASK_LONGWORD := MASK_LONGWORD'
  2265.      NULL_PARAMETER; 
  2266.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2267.      NULL_PARAMETER; 
  2268.    TERMINATOR_SET                      : in CHAR_STRING := CHAR_STRING'
  2269.      NULL_PARAMETER; 
  2270.    INI_OFFSET                          : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2271.      NULL_PARAMETER; 
  2272.    TERMINATOR_CODE                     : out WORD_UNSIGNED; 
  2273.    DISPLAY_ID                          : in LONGWORD_UNSIGNED := 
  2274.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2275.    ALT_ECHO_STRING                     : in CHAR_STRING := CHAR_STRING'
  2276.      NULL_PARAMETER; 
  2277.    ALT_DISPLAY_ID                      : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2278.      NULL_PARAMETER; 
  2279.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  2280.      NULL_PARAMETER); 
  2281.  
  2282.   procedure READ_VERIFY_1 --
  2283.   (KEYBOARD_ID                         : in LONGWORD_UNSIGNED; 
  2284.    OUT_STRING, IN_STRING               : out CHAR_STRING; 
  2285.    PIC_STRING, FILL_CHAR, CLEAR_CHAR   : in CHAR_STRING; 
  2286.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  2287.      NULL_PARAMETER; 
  2288.    MODIFIERS                           : in MASK_LONGWORD := MASK_LONGWORD'
  2289.      NULL_PARAMETER; 
  2290.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2291.      NULL_PARAMETER; 
  2292.    TERMINATOR_SET                      : in CHAR_STRING := CHAR_STRING'
  2293.      NULL_PARAMETER; 
  2294.    INI_OFFSET                          : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2295.      NULL_PARAMETER; 
  2296.    DISPLAY_ID                          : in LONGWORD_UNSIGNED := 
  2297.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2298.    ALT_ECHO_STRING                     : in CHAR_STRING := CHAR_STRING'
  2299.      NULL_PARAMETER; 
  2300.    ALT_DISPLAY_ID                      : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2301.      NULL_PARAMETER; 
  2302.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  2303.      NULL_PARAMETER); 
  2304.  
  2305.   procedure READ_VERIFY_1 --
  2306.   (STATUS                              : out COND_VALUE; 
  2307.    KEYBOARD_ID                         : in LONGWORD_UNSIGNED; 
  2308.    OUT_STRING, IN_STRING               : out CHAR_STRING; 
  2309.    PIC_STRING, FILL_CHAR, CLEAR_CHAR   : in CHAR_STRING; 
  2310.    PROMPT_STRING                       : in CHAR_STRING := CHAR_STRING'
  2311.      NULL_PARAMETER; 
  2312.    MODIFIERS                           : in MASK_LONGWORD := MASK_LONGWORD'
  2313.      NULL_PARAMETER; 
  2314.    TIMEOUT                             : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2315.      NULL_PARAMETER; 
  2316.    TERMINATOR_SET                      : in CHAR_STRING := CHAR_STRING'
  2317.      NULL_PARAMETER; 
  2318.    INI_OFFSET                          : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2319.      NULL_PARAMETER; 
  2320.    DISPLAY_ID                          : in LONGWORD_UNSIGNED := 
  2321.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2322.    ALT_ECHO_STRING                     : in CHAR_STRING := CHAR_STRING'
  2323.      NULL_PARAMETER; 
  2324.    ALT_DISPLAY_ID                      : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2325.      NULL_PARAMETER; 
  2326.    RENDITION_SET, RENDITION_COMPLEMENT : in MASK_LONGWORD := MASK_LONGWORD'
  2327.      NULL_PARAMETER); 
  2328.  
  2329.   pragma INTERFACE(RTL, READ_VERIFY); 
  2330.  
  2331.   pragma INTERFACE(RTL, READ_VERIFY_1); 
  2332.  
  2333.   pragma IMPORT_PROCEDURE(READ_VERIFY, "SMG$READ_VERIFY", (LONGWORD_UNSIGNED, 
  2334.     CHAR_STRING, CHAR_STRING, CHAR_STRING, CHAR_STRING, CHAR_STRING, CHAR_STRING
  2335.     , MASK_LONGWORD, LONGWORD_SIGNED, CHAR_STRING, LONGWORD_SIGNED, 
  2336.     WORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, 
  2337.     MASK_LONGWORD, MASK_LONGWORD)); 
  2338.  
  2339.   pragma IMPORT_PROCEDURE(READ_VERIFY, "SMG$READ_VERIFY", (COND_VALUE, 
  2340.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, CHAR_STRING, CHAR_STRING, 
  2341.     CHAR_STRING, CHAR_STRING, MASK_LONGWORD, LONGWORD_SIGNED, CHAR_STRING, 
  2342.     LONGWORD_SIGNED, WORD_UNSIGNED, LONGWORD_UNSIGNED, CHAR_STRING, 
  2343.     LONGWORD_SIGNED, MASK_LONGWORD, MASK_LONGWORD)); 
  2344.  
  2345.   pragma IMPORT_PROCEDURE(READ_VERIFY_1, "SMG$READ_VERIFY", (LONGWORD_UNSIGNED, 
  2346.     CHAR_STRING, CHAR_STRING, CHAR_STRING, CHAR_STRING, CHAR_STRING, CHAR_STRING
  2347.     , MASK_LONGWORD, LONGWORD_SIGNED, CHAR_STRING, LONGWORD_SIGNED, 
  2348.     LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, MASK_LONGWORD, 
  2349.     MASK_LONGWORD)); 
  2350.  
  2351.   pragma IMPORT_PROCEDURE(READ_VERIFY_1, "SMG$READ_VERIFY", (COND_VALUE, 
  2352.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, CHAR_STRING, CHAR_STRING, 
  2353.     CHAR_STRING, CHAR_STRING, MASK_LONGWORD, LONGWORD_SIGNED, CHAR_STRING, 
  2354.     LONGWORD_SIGNED, LONGWORD_UNSIGNED, CHAR_STRING, LONGWORD_SIGNED, 
  2355.     MASK_LONGWORD, MASK_LONGWORD)); 
  2356.  
  2357.   --------------------------------------------------------------------------
  2358.   --------------------------------------------------------------------------
  2359.   --    repaints a series of lines on the current screen.
  2360.   --
  2361.  
  2362.   procedure REPAINT_LINE --
  2363.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  2364.    ROW_START     : in LONGWORD_SIGNED; 
  2365.    NUM_OF_LINES  : in LONGWORD_SIGNED := LONGWORD_SIGNED'NULL_PARAMETER); 
  2366.  
  2367.   procedure REPAINT_LINE --
  2368.   (STATUS        : out COND_VALUE; 
  2369.    PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  2370.    ROW_START     : in LONGWORD_SIGNED; 
  2371.    NUM_OF_LINES  : in LONGWORD_SIGNED := LONGWORD_SIGNED'NULL_PARAMETER); 
  2372.  
  2373.   pragma INTERFACE(RTL, REPAINT_LINE); 
  2374.  
  2375.   pragma IMPORT_PROCEDURE(REPAINT_LINE, "SMG$REPAINT_LINE", (LONGWORD_UNSIGNED, 
  2376.     LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  2377.  
  2378.   pragma IMPORT_PROCEDURE(REPAINT_LINE, "SMG$REPAINT_LINE", (COND_VALUE, 
  2379.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  2380.  
  2381.   --------------------------------------------------------------------------
  2382.   --------------------------------------------------------------------------
  2383.   --    repaints the current screen after nonSMG I/O has occurred.
  2384.   --
  2385.  
  2386.   procedure REPAINT_SCREEN --
  2387.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  2388.  
  2389.   procedure REPAINT_SCREEN --
  2390.   (STATUS        : out COND_VALUE; 
  2391.    PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  2392.  
  2393.   pragma INTERFACE(RTL, REPAINT_SCREEN); 
  2394.  
  2395.   pragma IMPORT_PROCEDURE(REPAINT_SCREEN, "SMG$REPAINT_SCREEN", (
  2396.     LONGWORD_UNSIGNED)); 
  2397.  
  2398.   pragma IMPORT_PROCEDURE(REPAINT_SCREEN, "SMG$REPAINT_SCREEN", (COND_VALUE, 
  2399.     LONGWORD_UNSIGNED)); 
  2400.  
  2401.   --------------------------------------------------------------------------
  2402.   --------------------------------------------------------------------------
  2403.   --    moves a virtual display to a new position on the pasteboard.
  2404.   --    The pasting order is not preserved.
  2405.   --
  2406.  
  2407.   procedure REPASTE_VIRTUAL_DISPLAY --
  2408.   (DISPLAY_ID, PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  2409.    PB_ROW, PB_COLUMN         : in LONGWORD_SIGNED; 
  2410.    TOP_DISPLAY_ID            : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'
  2411.      NULL_PARAMETER); 
  2412.  
  2413.   procedure REPASTE_VIRTUAL_DISPLAY --
  2414.   (STATUS                    : out COND_VALUE; 
  2415.    DISPLAY_ID, PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  2416.    PB_ROW, PB_COLUMN         : in LONGWORD_SIGNED; 
  2417.    TOP_DISPLAY_ID            : in LONGWORD_UNSIGNED := LONGWORD_UNSIGNED'
  2418.      NULL_PARAMETER); 
  2419.  
  2420.   pragma INTERFACE(RTL, REPASTE_VIRTUAL_DISPLAY); 
  2421.  
  2422.   pragma IMPORT_PROCEDURE(REPASTE_VIRTUAL_DISPLAY, "SMG$REPASTE_VIRTUAL_DISPLAY"
  2423.     , (LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  2424.     LONGWORD_UNSIGNED)); 
  2425.  
  2426.   pragma IMPORT_PROCEDURE(REPASTE_VIRTUAL_DISPLAY, "SMG$REPASTE_VIRTUAL_DISPLAY"
  2427.     , (COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED, 
  2428.     LONGWORD_SIGNED, LONGWORD_UNSIGNED)); 
  2429.  
  2430.   -------------------------------------------------------------------------
  2431.   --    replaces the specified lines in the recall buffer with the 
  2432.   --    specified string.                                
  2433.   --
  2434.  
  2435.   procedure REPLACE_INPUT_LINE --
  2436.   (KEYBOARD_ID  : in LONGWORD_UNSIGNED; 
  2437.    OUT_LINE     : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  2438.    NUM_OF_LINES : in BYTE_UNSIGNED := BYTE_UNSIGNED'NULL_PARAMETER); 
  2439.  
  2440.   procedure REPLACE_INPUT_LINE --
  2441.   (STATUS       : out COND_VALUE; 
  2442.    KEYBOARD_ID  : in LONGWORD_UNSIGNED; 
  2443.    OUT_LINE     : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  2444.    NUM_OF_LINES : in BYTE_UNSIGNED := BYTE_UNSIGNED'NULL_PARAMETER); 
  2445.  
  2446.   pragma INTERFACE(RTL, REPLACE_INPUT_LINE); 
  2447.  
  2448.   pragma IMPORT_PROCEDURE(REPLACE_INPUT_LINE, "SMG$REPLACE_INPUT_LINE", (
  2449.     LONGWORD_UNSIGNED, CHAR_STRING, BYTE_UNSIGNED)); 
  2450.  
  2451.   pragma IMPORT_PROCEDURE(REPLACE_INPUT_LINE, "SMG$REPLACE_INPUT_LINE", (
  2452.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, BYTE_UNSIGNED)); 
  2453.  
  2454.   --------------------------------------------------------------------------
  2455.   --------------------------------------------------------------------------
  2456.   --    rewrites the screen image as it was at the time the 
  2457.   --    SMG$SAVE_PHYSICAL_SCREEN routine was called.
  2458.   --
  2459.  
  2460.   procedure RESTORE_PHYSICAL_SCREEN --
  2461.   (PASTEBOARD_ID, SAVED_DISPLAY_ID : in LONGWORD_UNSIGNED); 
  2462.  
  2463.   procedure RESTORE_PHYSICAL_SCREEN --
  2464.   (STATUS                          : out COND_VALUE; 
  2465.    PASTEBOARD_ID, SAVED_DISPLAY_ID : in LONGWORD_UNSIGNED); 
  2466.  
  2467.   pragma INTERFACE(RTL, RESTORE_PHYSICAL_SCREEN); 
  2468.  
  2469.   pragma IMPORT_PROCEDURE(RESTORE_PHYSICAL_SCREEN, "SMG$RESTORE_PHYSICAL_SCREEN"
  2470.     , (LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  2471.  
  2472.   pragma IMPORT_PROCEDURE(RESTORE_PHYSICAL_SCREEN, "SMG$RESTORE_PHYSICAL_SCREEN"
  2473.     , (COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  2474.  
  2475.   --------------------------------------------------------------------------
  2476.   --------------------------------------------------------------------------
  2477.   --    returns the current virtual cusor position in a specified
  2478.   --    virtual in a specified virtual display.
  2479.   --
  2480.  
  2481.   procedure RETURN_CURSOR_POS --
  2482.   (DISPLAY_ID                : in LONGWORD_UNSIGNED; 
  2483.    ROW_NUMBER, COLUMN_NUMBER : out LONGWORD_SIGNED); 
  2484.  
  2485.   procedure RETURN_CURSOR_POS --
  2486.   (STATUS                    : out COND_VALUE; 
  2487.    DISPLAY_ID                : in LONGWORD_UNSIGNED; 
  2488.    ROW_NUMBER, COLUMN_NUMBER : out LONGWORD_SIGNED); 
  2489.  
  2490.   pragma INTERFACE(RTL, RETURN_CURSOR_POS); 
  2491.  
  2492.   pragma IMPORT_PROCEDURE(RETURN_CURSOR_POS, "SMG$RETURN_CURSOR_POS", (
  2493.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  2494.  
  2495.   pragma IMPORT_PROCEDURE(RETURN_CURSOR_POS, "SMG$RETURN_CURSOR_POS", (
  2496.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  2497.  
  2498.   --------------------------------------------------------------------------
  2499.   --------------------------------------------------------------------------
  2500.   --    returns to the caller the requested line from the recall buffer.
  2501.   --    This line is retrieved either by matching it with a specified 
  2502.   --    string or by specifying the appropriate line number.
  2503.   --
  2504.  
  2505.   procedure RETURN_INPUT_LINE --
  2506.   (KEYBOARD_ID  : in LONGWORD_UNSIGNED; 
  2507.    OUT_LINE     : out CHAR_STRING; 
  2508.    MATCH_STRING : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  2509.    LINE_NUM     : in BYTE_UNSIGNED := BYTE_UNSIGNED'NULL_PARAMETER; 
  2510.    OUT_LENGTH   : out WORD_UNSIGNED); 
  2511.  
  2512.   procedure RETURN_INPUT_LINE --
  2513.   (STATUS       : out COND_VALUE; 
  2514.    KEYBOARD_ID  : in LONGWORD_UNSIGNED; 
  2515.    OUT_LINE     : out CHAR_STRING; 
  2516.    MATCH_STRING : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  2517.    LINE_NUM     : in BYTE_UNSIGNED := BYTE_UNSIGNED'NULL_PARAMETER; 
  2518.    OUT_LENGTH   : out WORD_UNSIGNED); 
  2519.  
  2520.   procedure RETURN_INPUT_LINE_1 --
  2521.   (KEYBOARD_ID  : in LONGWORD_UNSIGNED; 
  2522.    OUT_LINE     : out CHAR_STRING; 
  2523.    MATCH_STRING : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  2524.    LINE_NUM     : in BYTE_UNSIGNED := BYTE_UNSIGNED'NULL_PARAMETER); 
  2525.  
  2526.   procedure RETURN_INPUT_LINE_1 --
  2527.   (STATUS       : out COND_VALUE; 
  2528.    KEYBOARD_ID  : in LONGWORD_UNSIGNED; 
  2529.    OUT_LINE     : out CHAR_STRING; 
  2530.    MATCH_STRING : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  2531.    LINE_NUM     : in BYTE_UNSIGNED := BYTE_UNSIGNED'NULL_PARAMETER); 
  2532.  
  2533.   pragma INTERFACE(RTL, RETURN_INPUT_LINE); 
  2534.  
  2535.   pragma INTERFACE(RTL, RETURN_INPUT_LINE_1); 
  2536.  
  2537.   pragma IMPORT_PROCEDURE(RETURN_INPUT_LINE, "SMG$RETURN_INPUT_LINE", (
  2538.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, BYTE_UNSIGNED, WORD_UNSIGNED))
  2539.     ; 
  2540.  
  2541.   pragma IMPORT_PROCEDURE(RETURN_INPUT_LINE, "SMG$RETURN_INPUT_LINE", (
  2542.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, BYTE_UNSIGNED, 
  2543.     WORD_UNSIGNED)); 
  2544.  
  2545.   pragma IMPORT_PROCEDURE(RETURN_INPUT_LINE_1, "SMG$RETURN_INPUT_LINE", (
  2546.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, BYTE_UNSIGNED)); 
  2547.  
  2548.   pragma IMPORT_PROCEDURE(RETURN_INPUT_LINE_1, "SMG$RETURN_INPUT_LINE", (
  2549.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING, BYTE_UNSIGNED)); 
  2550.  
  2551.   --------------------------------------------------------------------------
  2552.   --------------------------------------------------------------------------
  2553.   --    sound the terminal bell or buzzer.
  2554.   --
  2555.  
  2556.   procedure RING_BELL --
  2557.   (DISPLAY_ID      : in LONGWORD_UNSIGNED; 
  2558.    NUMBER_OF_TIMES : in LONGWORD_SIGNED := LONGWORD_SIGNED'NULL_PARAMETER); 
  2559.  
  2560.   procedure RING_BELL --
  2561.   (STATUS          : out COND_VALUE; 
  2562.    DISPLAY_ID      : in LONGWORD_UNSIGNED; 
  2563.    NUMBER_OF_TIMES : in LONGWORD_SIGNED := LONGWORD_SIGNED'NULL_PARAMETER); 
  2564.  
  2565.   pragma INTERFACE(RTL, RING_BELL); 
  2566.  
  2567.   pragma IMPORT_PROCEDURE(RING_BELL, "SMG$RING_BELL", (LONGWORD_UNSIGNED, 
  2568.     LONGWORD_SIGNED)); 
  2569.  
  2570.   pragma IMPORT_PROCEDURE(RING_BELL, "SMG$RING_BELL", (COND_VALUE, 
  2571.     LONGWORD_UNSIGNED, LONGWORD_SIGNED)); 
  2572.  
  2573.   --------------------------------------------------------------------------
  2574.   --------------------------------------------------------------------------
  2575.   --    saves the contents of the screen so that a later call to 
  2576.   --    SMG$RESTORE_PHYSICAL_SCREEN can restore it.
  2577.   --
  2578.  
  2579.   procedure SAVE_PHYSICAL_SCREEN --
  2580.   (PASTEBOARD_ID                      : in LONGWORD_UNSIGNED; 
  2581.    SAVED_DISPLAY_ID                   : out LONGWORD_UNSIGNED; 
  2582.    DESIRED_ROW_START, DESIRED_ROW_END : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2583.      NULL_PARAMETER); 
  2584.  
  2585.   procedure SAVE_PHYSICAL_SCREEN --
  2586.   (STATUS                             : out COND_VALUE; 
  2587.    PASTEBOARD_ID                      : in LONGWORD_UNSIGNED; 
  2588.    SAVED_DISPLAY_ID                   : out LONGWORD_UNSIGNED; 
  2589.    DESIRED_ROW_START, DESIRED_ROW_END : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2590.      NULL_PARAMETER); 
  2591.  
  2592.   pragma INTERFACE(RTL, SAVE_PHYSICAL_SCREEN); 
  2593.  
  2594.   pragma IMPORT_PROCEDURE(SAVE_PHYSICAL_SCREEN, "SMG$SAVE_PHYSICAL_SCREEN", (
  2595.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  2596.  
  2597.   pragma IMPORT_PROCEDURE(SAVE_PHYSICAL_SCREEN, "SMG$SAVE_PHYSICAL_SCREEN", (
  2598.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED, 
  2599.     LONGWORD_SIGNED)); 
  2600.  
  2601.   --------------------------------------------------------------------------
  2602.   --------------------------------------------------------------------------
  2603.   --    scrolls a rectangular region of a virtual display.
  2604.   --
  2605.  
  2606.   procedure SCROLL_DISPLAY_AREA --
  2607.   (DISPLAY_ID                                   : in LONGWORD_UNSIGNED; 
  2608.    STARTING_ROW, STARTING_COLUMN, HEIGHT, WIDTH : in LONGWORD_SIGNED := 
  2609.      LONGWORD_SIGNED'NULL_PARAMETER; 
  2610.    DIRECTION                                    : in LONGWORD_UNSIGNED := 
  2611.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2612.    COUNT                                        : out LONGWORD_SIGNED); 
  2613.  
  2614.   procedure SCROLL_DISPLAY_AREA --
  2615.   (STATUS                                       : out COND_VALUE; 
  2616.    DISPLAY_ID                                   : in LONGWORD_UNSIGNED; 
  2617.    STARTING_ROW, STARTING_COLUMN, HEIGHT, WIDTH : in LONGWORD_SIGNED := 
  2618.      LONGWORD_SIGNED'NULL_PARAMETER; 
  2619.    DIRECTION                                    : in LONGWORD_UNSIGNED := 
  2620.      LONGWORD_UNSIGNED'NULL_PARAMETER; 
  2621.    COUNT                                        : out LONGWORD_SIGNED); 
  2622.  
  2623.   pragma INTERFACE(RTL, SCROLL_DISPLAY_AREA); 
  2624.  
  2625.   pragma IMPORT_PROCEDURE(SCROLL_DISPLAY_AREA, "SMG$SCROLL_DISPLAY_AREA", (
  2626.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  2627.     LONGWORD_SIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED)); 
  2628.  
  2629.   pragma IMPORT_PROCEDURE(SCROLL_DISPLAY_AREA, "SMG$SCROLL_DISPLAY_AREA", (
  2630.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED, 
  2631.     LONGWORD_SIGNED, LONGWORD_SIGNED, LONGWORD_UNSIGNED, LONGWORD_SIGNED)); 
  2632.  
  2633.   --------------------------------------------------------------------------
  2634.   --------------------------------------------------------------------------
  2635.   --    enables the trapping of broadcast messages.
  2636.   --
  2637.  
  2638.   procedure SET_BROADCAST_TRAPPING --
  2639.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  2640.    AST_ROUTINE   : in AST_PROCEDURE := AST_PROCEDURE'NULL_PARAMETER; 
  2641.    AST_ARGUMENT  : in USER_ARG := USER_ARG'NULL_PARAMETER); 
  2642.  
  2643.   procedure SET_BROADCAST_TRAPPING --
  2644.   (STATUS        : out COND_VALUE; 
  2645.    PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  2646.    AST_ROUTINE   : in AST_PROCEDURE := AST_PROCEDURE'NULL_PARAMETER; 
  2647.    AST_ARGUMENT  : in USER_ARG := USER_ARG'NULL_PARAMETER); 
  2648.  
  2649.   pragma INTERFACE(RTL, SET_BROADCAST_TRAPPING); 
  2650.  
  2651.   pragma IMPORT_PROCEDURE(SET_BROADCAST_TRAPPING, "SMG$SET_BROADCAST_TRAPPING", 
  2652.     (LONGWORD_UNSIGNED, AST_PROCEDURE, USER_ARG)); 
  2653.  
  2654.   pragma IMPORT_PROCEDURE(SET_BROADCAST_TRAPPING, "SMG$SET_BROADCAST_TRAPPING", 
  2655.     (COND_VALUE, LONGWORD_UNSIGNED, AST_PROCEDURE, USER_ARG)); 
  2656.  
  2657.   --------------------------------------------------------------------------
  2658.   --------------------------------------------------------------------------
  2659.   --    moves the virtual cursor to the specified position in a virtual
  2660.   --    dispaly.
  2661.   --
  2662.  
  2663.   procedure SET_CURSOR_ABS --
  2664.   (DISPLAY_ID  : in LONGWORD_UNSIGNED; 
  2665.    ROW, COLUMN : in LONGWORD_SIGNED ); 
  2666.  
  2667.   procedure SET_CURSOR_ABS --
  2668.   (STATUS      : out COND_VALUE; 
  2669.    DISPLAY_ID  : in LONGWORD_UNSIGNED; 
  2670.    ROW, COLUMN : in LONGWORD_SIGNED ); 
  2671.  
  2672.   pragma INTERFACE(RTL, SET_CURSOR_ABS); 
  2673.  
  2674.   pragma IMPORT_PROCEDURE(SET_CURSOR_ABS, "SMG$SET_CURSOR_ABS", (
  2675.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  2676.  
  2677.   pragma IMPORT_PROCEDURE(SET_CURSOR_ABS, "SMG$SET_CURSOR_ABS", (COND_VALUE, 
  2678.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  2679.  
  2680.   --------------------------------------------------------------------------
  2681.   --------------------------------------------------------------------------
  2682.   --    turns the physical cursor on or off.
  2683.   --
  2684.  
  2685.   procedure SET_CURSOR_MODE --
  2686.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  2687.    CURSOR_MODE   : in BOOLEAN); 
  2688.  
  2689.   procedure SET_CURSOR_MODE --
  2690.   (STATUS        : out COND_VALUE; 
  2691.    PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  2692.    CURSOR_MODE   : in BOOLEAN); 
  2693.  
  2694.   pragma INTERFACE(RTL, SET_CURSOR_MODE); 
  2695.  
  2696.   pragma IMPORT_PROCEDURE(SET_CURSOR_MODE, "SMG$SET_CURSOR_MODE", (
  2697.     LONGWORD_UNSIGNED, BOOLEAN)); 
  2698.  
  2699.   pragma IMPORT_PROCEDURE(SET_CURSOR_MODE, "SMG$SET_CURSOR_MODE", (COND_VALUE, 
  2700.     LONGWORD_UNSIGNED, BOOLEAN)); 
  2701.  
  2702.   --------------------------------------------------------------------------
  2703.   --------------------------------------------------------------------------
  2704.   --    moves the virtual cursor the specified number of rows and
  2705.   --    columns from the current virtual cursor position in a virtual 
  2706.   --    display.
  2707.   --
  2708.  
  2709.   procedure SET_CURSOR_REL --
  2710.   (DISPLAY_ID              : in LONGWORD_UNSIGNED; 
  2711.    DELTA_ROW, DELTA_COLUMN : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2712.      NULL_PARAMETER); 
  2713.  
  2714.   procedure SET_CURSOR_REL --
  2715.   (STATUS                  : out COND_VALUE; 
  2716.    DISPLAY_ID              : in LONGWORD_UNSIGNED; 
  2717.    DELTA_ROW, DELTA_COLUMN : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2718.      NULL_PARAMETER); 
  2719.  
  2720.   pragma INTERFACE(RTL, SET_CURSOR_REL); 
  2721.  
  2722.   pragma IMPORT_PROCEDURE(SET_CURSOR_REL, "SMG$SET_CURSOR_REL", (
  2723.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  2724.  
  2725.   pragma IMPORT_PROCEDURE(SET_CURSOR_REL, "SMG$SET_CURSOR_REL", (COND_VALUE, 
  2726.     LONGWORD_UNSIGNED, LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  2727.  
  2728.   --------------------------------------------------------------------------
  2729.   --------------------------------------------------------------------------
  2730.   --    sets and/or returns the current default state for a key table.
  2731.   --
  2732.  
  2733.   procedure SET_DEFAULT_STATE --
  2734.   (KEY_TABLE_ID : in LONGWORD_UNSIGNED; 
  2735.    NEW_STATE    : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  2736.    OLD_STATE    : out CHAR_STRING); 
  2737.  
  2738.   procedure SET_DEFAULT_STATE --
  2739.   (STATUS       : out COND_VALUE; 
  2740.    KEY_TABLE_ID : in LONGWORD_UNSIGNED; 
  2741.    NEW_STATE    : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER; 
  2742.    OLD_STATE    : out CHAR_STRING); 
  2743.  
  2744.   procedure SET_DEFAULT_STATE_1 --
  2745.   (KEY_TABLE_ID : in LONGWORD_UNSIGNED; 
  2746.    NEW_STATE    : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER); 
  2747.  
  2748.   procedure SET_DEFAULT_STATE_1 --
  2749.   (STATUS       : out COND_VALUE; 
  2750.    KEY_TABLE_ID : in LONGWORD_UNSIGNED; 
  2751.    NEW_STATE    : in CHAR_STRING := CHAR_STRING'NULL_PARAMETER); 
  2752.  
  2753.   pragma INTERFACE(RTL, SET_DEFAULT_STATE); 
  2754.  
  2755.   pragma INTERFACE(RTL, SET_DEFAULT_STATE_1); 
  2756.  
  2757.   pragma IMPORT_PROCEDURE(SET_DEFAULT_STATE, "SMG$SET_DEFAULT_STATE", (
  2758.     LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING)); 
  2759.  
  2760.   pragma IMPORT_PROCEDURE(SET_DEFAULT_STATE, "SMG$SET_DEFAULT_STATE", (
  2761.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING, CHAR_STRING)); 
  2762.  
  2763.   pragma IMPORT_PROCEDURE(SET_DEFAULT_STATE_1, "SMG$SET_DEFAULT_STATE", (
  2764.     LONGWORD_UNSIGNED, CHAR_STRING)); 
  2765.  
  2766.   pragma IMPORT_PROCEDURE(SET_DEFAULT_STATE_1, "SMG$SET_DEFAULT_STATE", (
  2767.     COND_VALUE, LONGWORD_UNSIGNED, CHAR_STRING)); 
  2768.  
  2769.   --------------------------------------------------------------------------
  2770.   --------------------------------------------------------------------------
  2771.   --    creates a scrolling region in a virtual display.
  2772.   --
  2773.  
  2774.   procedure SET_DISPLAY_SCROLL_REGION --
  2775.   (DISPLAY_ID                 : in LONGWORD_UNSIGNED; 
  2776.    STARTING_LINE, ENDING_LINE : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2777.      NULL_PARAMETER); 
  2778.  
  2779.   procedure SET_DISPLAY_SCROLL_REGION --
  2780.   (STATUS                     : out COND_VALUE; 
  2781.    DISPLAY_ID                 : in LONGWORD_UNSIGNED; 
  2782.    STARTING_LINE, ENDING_LINE : in LONGWORD_SIGNED := LONGWORD_SIGNED'
  2783.      NULL_PARAMETER); 
  2784.  
  2785.   pragma INTERFACE(RTL, SET_DISPLAY_SCROLL_REGION); 
  2786.  
  2787.   pragma IMPORT_PROCEDURE(SET_DISPLAY_SCROLL_REGION, 
  2788.     "SMG$SET_DISPLAY_SCROLL_REGION", (LONGWORD_UNSIGNED, LONGWORD_SIGNED, 
  2789.     LONGWORD_SIGNED)); 
  2790.  
  2791.   pragma IMPORT_PROCEDURE(SET_DISPLAY_SCROLL_REGION, 
  2792.     "SMG$SET_DISPLAY_SCROLL_REGION", (COND_VALUE, LONGWORD_UNSIGNED, 
  2793.     LONGWORD_SIGNED, LONGWORD_SIGNED)); 
  2794.  
  2795.   --------------------------------------------------------------------------
  2796.   --------------------------------------------------------------------------
  2797.   --    sets the terminal's numeric keypad to either nuneric or
  2798.   --    applications mode.
  2799.   --
  2800.  
  2801.   procedure SET_KEYPAD_MODE --
  2802.   (KEYBOARD_ID, NEW_MODE : in LONGWORD_UNSIGNED); 
  2803.  
  2804.   procedure SET_KEYPAD_MODE --
  2805.   (STATUS                : out COND_VALUE; 
  2806.    KEYBOARD_ID, NEW_MODE : in LONGWORD_UNSIGNED); 
  2807.  
  2808.   pragma INTERFACE(RTL, SET_KEYPAD_MODE); 
  2809.  
  2810.   pragma IMPORT_PROCEDURE(SET_KEYPAD_MODE, "SMG$SET_KEYPAD_MODE", (
  2811.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  2812.  
  2813.   pragma IMPORT_PROCEDURE(SET_KEYPAD_MODE, "SMG$SET_KEYPAD_MODE", (COND_VALUE, 
  2814.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  2815.  
  2816.   --------------------------------------------------------------------------
  2817.   --------------------------------------------------------------------------
  2818.   --    either enables or disables the trapping of out-of-band
  2819.   --    characters.
  2820.   -- 
  2821.  
  2822.   procedure SET_OUT_OF_BAND_ASTS --
  2823.   (PASTEBOARD_ID     : in LONGWORD_UNSIGNED; 
  2824.    CONTROL_CHAR_MASK : in MASK_LONGWORD; 
  2825.    AST_ROUTINE       : in AST_PROCEDURE; 
  2826.    AST_ARGUMENT      : in USER_ARG := USER_ARG'NULL_PARAMETER); 
  2827.  
  2828.   procedure SET_OUT_OF_BAND_ASTS --
  2829.   (STATUS            : out COND_VALUE; 
  2830.    PASTEBOARD_ID     : in LONGWORD_UNSIGNED; 
  2831.    CONTROL_CHAR_MASK : in MASK_LONGWORD; 
  2832.    AST_ROUTINE       : in AST_PROCEDURE; 
  2833.    AST_ARGUMENT      : in USER_ARG := USER_ARG'NULL_PARAMETER); 
  2834.  
  2835.   pragma INTERFACE(RTL, SET_OUT_OF_BAND_ASTS); 
  2836.  
  2837.   pragma IMPORT_PROCEDURE(SET_OUT_OF_BAND_ASTS, "SMG$SET_OUT_OF_BAND_ASTS", (
  2838.     LONGWORD_UNSIGNED, MASK_LONGWORD, AST_PROCEDURE, USER_ARG)); 
  2839.  
  2840.   pragma IMPORT_PROCEDURE(SET_OUT_OF_BAND_ASTS, "SMG$SET_OUT_OF_BAND_ASTS", (
  2841.     COND_VALUE, LONGWORD_UNSIGNED, MASK_LONGWORD, AST_PROCEDURE, USER_ARG)); 
  2842.  
  2843.   --------------------------------------------------------------------------
  2844.   --------------------------------------------------------------------------
  2845.   --    moves the physical cursor to the specified position on the
  2846.   --    physical screen.
  2847.   --
  2848.  
  2849.   procedure SET_PHYSICAL_CURSOR --
  2850.   (PASTEBOARD_ID, PB_ROW, PB_COLUMN : in LONGWORD_UNSIGNED); 
  2851.  
  2852.   procedure SET_PHYSICAL_CURSOR --
  2853.   (STATUS                           : out COND_VALUE; 
  2854.    PASTEBOARD_ID, PB_ROW, PB_COLUMN : in LONGWORD_UNSIGNED); 
  2855.  
  2856.   pragma INTERFACE(RTL, SET_PHYSICAL_CURSOR); 
  2857.  
  2858.   pragma IMPORT_PROCEDURE(SET_PHYSICAL_CURSOR, "SMG$SET_PHYSICAL_CURSOR", (
  2859.     LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  2860.  
  2861.   pragma IMPORT_PROCEDURE(SET_PHYSICAL_CURSOR, "SMG$SET_PHYSICAL_CURSOR", (
  2862.     COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  2863.  
  2864.   --------------------------------------------------------------------------
  2865.   --------------------------------------------------------------------------
  2866.   --    writes the current pasteboard buffer to the file or hardcopy
  2867.   --    terminal specified by pasteboard-id.
  2868.   --
  2869.  
  2870.   procedure SNAPSHOT --
  2871.   (PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  2872.    FF_FLAG       : in BOOLEAN); 
  2873.  
  2874.   procedure SNAPSHOT --
  2875.   (STATUS        : out COND_VALUE; 
  2876.    PASTEBOARD_ID : in LONGWORD_UNSIGNED; 
  2877.    FF_FLAG       : in BOOLEAN); 
  2878.  
  2879.   pragma INTERFACE(RTL, SNAPSHOT); 
  2880.  
  2881.   pragma IMPORT_PROCEDURE(SNAPSHOT, "SMG$SNAPSHOT", (LONGWORD_UNSIGNED, BOOLEAN)
  2882.     ); 
  2883.  
  2884.   pragma IMPORT_PROCEDURE(SNAPSHOT, "SMG$SNAPSHOT", (COND_VALUE, 
  2885.     LONGWORD_UNSIGNED, BOOLEAN)); 
  2886.  
  2887.   --------------------------------------------------------------------------
  2888.   --------------------------------------------------------------------------
  2889.   --    removes a virtual display from a pasteboard.
  2890.   --
  2891.  
  2892.   procedure UNPASTE_VIRTUAL_DISPLAY --
  2893.   (DISPLAY_ID, PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  2894.  
  2895.   procedure UNPASTE_VIRTUAL_DISPLAY --
  2896.   (STATUS                    : out COND_VALUE; 
  2897.    DISPLAY_ID, PASTEBOARD_ID : in LONGWORD_UNSIGNED); 
  2898.  
  2899.   pragma INTERFACE(RTL, UNPASTE_VIRTUAL_DISPLAY); 
  2900.  
  2901.   pragma IMPORT_PROCEDURE(UNPASTE_VIRTUAL_DISPLAY, "SMG$UNPASTE_VIRTUAL_DISPLAY"
  2902.     , (LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  2903.  
  2904.   pragma IMPORT_PROCEDURE(UNPASTE_VIRTUAL_DISPLAY, "SMG$UNPASTE_VIRTUAL_DISPLAY"
  2905.     , (COND_VALUE, LONGWORD_UNSIGNED, LONGWORD_UNSIGNED)); 
  2906.  
  2907. end SMG; 
  2908.